freesect (empty) → 0.0.5
raw patch · 39 files changed
+23907/−0 lines, 39 filesdep +arraydep +basedep +cpphsbuild-type:Customsetup-changed
Dependencies added: array, base, cpphs, haskell98, mtl, parallel, pretty, syb
Files
- 000-readme +32/−0
- Doc/index.html +224/−0
- Doc/irc.html +97/−0
- FilesAndParsing.hs +130/−0
- HSE.hs +114/−0
- HSE/Annotated.hs +124/−0
- HSE/Annotated/Build.hs +300/−0
- HSE/Annotated/ExactPrint.hs +1747/−0
- HSE/Annotated/Fixity.hs +342/−0
- HSE/Annotated/Simplify.hs +522/−0
- HSE/Annotated/Syntax.hs +2231/−0
- HSE/Build.hs +300/−0
- HSE/Comments.hs +20/−0
- HSE/ExtScheme.hs +37/−0
- HSE/Extension.hs +249/−0
- HSE/Fixity.hs +399/−0
- HSE/InternalParser.hs +8103/−0
- HSE/InternalParser.ly +1862/−0
- HSE/Lexer.hs +1326/−0
- HSE/ParseMonad.hs +428/−0
- HSE/ParseSyntax.hs +448/−0
- HSE/ParseUtils.hs +952/−0
- HSE/Parser.hs +174/−0
- HSE/Pretty.hs +1661/−0
- HSE/SrcLoc.hs +173/−0
- HSE/Syntax.hs +1002/−0
- LICENSE +30/−0
- Main.hs +511/−0
- Makefile +16/−0
- S14.hs +20/−0
- S15.hs +13/−0
- S23.hs +18/−0
- Setup.hs +5/−0
- cln +26/−0
- freesect.cabal +75/−0
- freesect.sh +13/−0
- ile +29/−0
- z +128/−0
- zz +26/−0
+ 000-readme view
@@ -0,0 +1,32 @@++Wed Feb 29 20:03:57 EST 2012++There is a snapshot of documentation in Doc, but please visit the+homepage for up-to-date versions: http://www.fremissant.net/freesect++Tested with Haskell Platforms 6.12.3 and 7.0.4.+Testing has not been very extensive yet.+Will try to get a quickcheck harness into freesect-0.0.6.++A patched version of haskell-src-exts is used.+These patched modules are provisionally renamed HSE to avoid confusion.++I think it is HSE which makes the executable so big?++To compile, you need syb installed, as well as some dependencies+of the HSE code (the freesect.cabal file details dependencies).++cabal-install should work, but in case not, you can build it manually.+To build and run, please have csh (or tcsh), and run the ./z script:++./z++The script is hardcoded to use the S14.hs test file, but+you can easily adjust that.++Preprocessed outputs can be examined in ./ghc* directories.++For more information, visit http://www.fremissant.net/freesect++Andrew Seniuk (rasfar@gmail.com)+
+ Doc/index.html view
@@ -0,0 +1,224 @@+<html>+<head>+<title>Free Sections : A Haskell Syntax Extension</title>+<!--LINK HREF="base.css" REL="stylesheet" TYPE="text/css"-->+<style type="text/css">/*<![CDATA[*/+body { font-family: "Ariel"; font-size: 17; }+h2 {+ color: #222;+ font-size: 16pt;+ margin-top: 24px;+ margin-bottom: 16px;+}+pre-inline {+ font-family: "Courier New";+ padding: 0 0 0 0;+ margin: 0 0 0 0;+ border: 0 0 0 0;+}+pre.showhide2 {+ font-family: "Courier New";+ padding: 0 0 0 0;+ margin: 0 0 0 0;+ border: 0 0 0 0;+}+pre.showhide3 {+ font-family: "Courier New";+ padding: 0 0 0 0;+ margin: 0 0 0 0;+ border: 0 0 0 0;+}+A:link { font-weight: bold; color: #27e; text-decoration: none; }+A:visited { font-weight: bold; color: #14a; text-decoration: none; }+A:hover { font-weight: bold; color: #795; text-decoration: none; }+/*]]>*/+</style>+<script type="text/javascript">+function collapse(button,cls)+{+ var goodies = document.querySelectorAll(cls);+ for( var i=0;i<goodies.length;i++ ){+ n = goodies[i].style;+ if( n.display == "none" ){+ n.display = "block";+ }else{+ n.display = "none";+ }+ }+}+</script>+</head>+<body>+<p>+<h1 style="font-size: 22pt; margin-bottom: 0;">Free Sections</h1>+<h3 style="margin-top: 10px; margin-bottom: 0;">Haskell Syntax Extension</h3>+<h5 style="margin-top: 10px; margin-bottom: 28px;">by Andrew Seniuk</h5>++<div style="color: #B52; font-size: 9pt; font-weight: bold; margin-left: 20px; margin-right: 20%; margin-bottom: 15px; margin-top: 10px;">The reader is strongly encouraged to navigate to <a href="http://www.fremissant.net/freesect">fremissant.net/freesect</a> as these documents are currently experiencing rapid growth and refinement. The local files represent the best documentation available at packaging of this v.0.0.5 source distribution (March 11, 2012).</div>++<i>Free sections</i> are syntactic sugar to extend the usual notion of "section" in functional programming.+Recall that a section is just a function which has been applied to some but not all of its arguments.+Unless the function is modified, arguments must be supplied in the lexical order determined by the function binding's parameters.+For instance, <pre-inline>sect</pre-inline> is partially applied, but is still a function type and can absorb two more arguments of types <pre-inline>Char</pre-inline> and <pre-inline>Float</pre-inline>, in that order.++<pre>+ f :: Int -> Bool -> Char -> Float -> String+ sect = f 4 True -- Char -> Float -> String+</pre>++By using wildcard symbols (<pre-inline>__</pre-inline>, a double-underscore), any subset of values occurring in a RHS context can be deferred, in the same spirit as partial function application.+Special brackets (<pre-inline>_[…]_</pre-inline>) are used to delimit the lexical extent (or context) of the section, although these could sometimes be omitted (details below).+The free section is then a function with arity at least equal to the number of wildcards, and behaves as if a helper function had been defined which shuffled the argument order of the functional expression, turning it into a normal section.+<p>+Some examples, including illustrations of context inferencing.+<ul>+<li><pre-inline>_[ __ ]_ <=> ( __ ) <=> id</pre-inline></li>+<li><pre-inline>map _[ (+) __ 2 ]_ [1,2,3] => [3,4,5]</pre-inline></li>+<li><pre-inline>map ( (+) __ 2 ) [1,2,3] => [3,4,5]</pre-inline></li>+<li><pre-inline>zipWith $ f __ $ g __ z <=> zipWith _[ f __ $ g __ z ]_</pre-inline></li>+</ul>+<p>+An more complex example...+<p>+Here I depict a situation where some API provides you with the dreaded <pre-inline>dreadme</pre-inline> function, which you have need of using.+The example is designed to show that you can really put the <pre-inline>__</pre-inline>'s anywhere on a RHS that an expression can go.++<pre>+ {-# LANGUAGE FreeSections #-} -- use "{- #" if compiling with ghc -F++ tableA = [ [1,2,3], [4,5], [6,7,8,9] ]+ tableB = [ [9,8,7], [6,5], [4,3,2,1] ]++ data D a = D Int [a]++ v = map3 _[ dreadme tableA __ (repeat True,__) (D __ [(+),(*)]) ]_+ [tableA,tableB]+ [0..]+ [-1,1]+</pre>++FreeSect rewrites the RHS of <pre-inline>rslt</pre-inline> (where <pre-inline>fs0…fs2</pre-inline> must be fresh identifiers) to:++<pre>+ v = map3 (\ fs0 fs1 fs2 -> dreadme tableA fs0 (repeat True,fs1) (D fs2 [(+),(*)]) )+ [tableA,tableB]+ [0..]+ [-1,1]+</pre>++(Here is <a id="collapsed1" href="#collapsed1" onclick="collapse(this,'.showhide1');">the rest</a> of the code to make a closed module.)++<pre class="showhide1" style="display: none;">+ dreadme :: [[Int]] -> [[Int]] -> ([Bool],Int) -> D (Int->Int->Int) -> String+ dreadme tabA tabB (ps,q) (D wt flst)+ = show $ map (!!q) $ map2 f tabA tabB+ where f :: [Int] -> [Int] -> [Bool]+ f rowA rowB = map2 (==) (repeat rowA)+ $ map2' flst' rowB (map ((q+).(wt*)) rowB)+ flst' = filter' ps flst+(<a id="collapsed2" href="#collapsed2" onclick="collapse(this,'.showhide2'); collapse(this,'.showhide3');">base cases</a>)<pre class="showhide2" style="display: block;">+ filter' :: [Bool] -> [a] -> [a]+ filter' (p:ps) (x:xs) = if p then x:filter' ps xs+ else filter' ps xs+ map2 :: (a->b->c) -> [a] -> [b] -> [c]+ map2 f (x:xs) (y:ys) = (f x y) : map2 f xs ys+ map2' :: [a->a->a] -> [a] -> [a] -> [[a]]+ map2' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys+ map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]+ map3 f (x:xs) (y:ys) (z:zs) = (f x y z) : map3 f xs ys zs+</pre><pre class="showhide3" style="display: none;">+ filter' :: [Bool] -> [a] -> [a]+ filter' (p:ps) (x:xs) = if p then x:filter' ps xs+ else filter' ps xs+ map2 :: (a->b->c) -> [a] -> [b] -> [c]+ map2 f _ [] = []+ map2 f [] _ = []+ map2 f (x:xs) (y:ys) = (f x y) : map2 f xs ys+ map2' :: [a->a->a] -> [a] -> [a] -> [[a]]+ map2' _ _ [] = []+ map2' _ [] _ = []+ map2' [] _ _ = []+ map2' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys+ map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]+ map3 f _ _ [] = []+ map3 f _ [] _ = []+ map3 f [] _ _ = []+ map3 f (x:xs) (y:ys) (z:zs) = (f x y z) : map3 f xs ys zs+ main = print v+</pre></pre>++<h2>Some virtues of the new syntax</h2>++Although the rewrite provided by the extension is simple, there are advantages of free sections relative to explicitly written lambdas:+<ul>+<li>the lambda forces the programmer to invent names for the wildcards</li>+<li>the lambda forces the programmer to repeat those names, and place them correctly</li>+<li>freesect wildcards stand out vividly, indicating where the awaited expressions will go</li>+<li>reading the lambda requires visual pattern-matching between left and right sides of the lambda+<li>the lambda is longer overall, and prefaces the expression of interest with something like micro-boilerplate</li>+</ul>++On the other hand, the lambda is more powerful and can achieve arbitrary permutations without further ado.++<h2>Implementation</h2>++The <a href="freesect-0.0.5.tar.gz">implementation</a> seems to be working.+The freesect package can also be installed from hackage.haskell.org, for instance using cabal-install.+I offer fair warning that I'm <i>not</i> a good Haskell coder, but this does demonstrate how a person of modest abilities can use <a href="http://www.hackage.haskell.org/package/syb">SYB</a> with <a href="http://www.hackage.haskell.org/package/haskell-src-exts">HSE</a> to create a robust Haskell syntax extension.++<h2>Background</h2>++There was <a href="irc.html">discussion</a> about this on the #haskell IRC channel.+Strangely, eyebloom suggested the same thing about an hour after I had started making inquiries about how to go about writing an extension, and this is the one I had in mind.+It's an extraordinary coincidence, as I first sketched the idea in 2003, and had never seen it mentioned per se, beyond discussions of point-free and the like.+(Despite eyebloom asking to be contacted if I wanted to work on this, my email was never answered.)+Some of the examples mentioned in the chat have been presented above, to show how FreeSect deals with them.++<h2>Other details</h2>++Nested free sections work correctly, thanks to bottom-up traversal.+Note that, as wildcards are syntactically indistinguishable, it is impossible for an outermore freesect to place a wildcard inside an innermore freesect.+<p>+Temporary names created by FreeSect are guaranteed to be unique among names referenced within a module.+Imported names which are in scope but never used will not incur conflicts.+Also, there is no danger of exporting the temporary names inadvertently, as they never have top-level scope.+<p>+A default context is automatically applied when the <pre-inline>_[…]_</pre-inline> grouping syntax is omitted.+Defining this default can be tricky, and a bit arbitrary, so for robust code it's best to use explicit bracketing.+As of v.0.0.5, when the <pre-inline>_[…]_</pre-inline> are omitted, the defaulting rules are as follows:+The semilattice join of all unbacketed wildcards in a RHS are given context of the innermost enclosing parentheses or infix $ operation.+If no such parentheses or infix $ are present, the whole RHS becomes the default context.+Some of the examples at the top of the page demonstrate these rules.+One hopes that the default will result in a type error, should the inferred context differ from the intended.+I haven't thought of any situation where more than one bracketing of freesect wildcards yield typeable expressions, but neither have I ruled it out.+<p>+Philosophically, use of this sort of syntax promotes "higher-order programming", since any expression can so easily be made into a function, in numerous ways, simply by replacing parts of it with freesect wildcards.+That this is worthwhile is demonstrated frequently by usefulness of sections.++<h2>Work in progress</h2>+A few things don't work quite right yet.+Free sections in let expressions are one.+Also, guarded RHS's are not yet handled.+Work continues...++<h2>How to run it</h2>++The extension runs as a preprocessor.+This can be done with or without the knowledge of GHC.+If you use <pre-inline>ghc -F</pre-inline> (see scripts in the download), then unfortunately GHC checks language pragmas before preprocessing, which means you cannot declare <pre-inline>{-# LANGUAGE FreeSections #-}</pre-inline> at the top.+Although the patched HSE is capable of rejecting source which uses free sections without the pragma, this feature is disabled for interoperability with GHC.+All compilers are supported by running freesect as an independent preprocessor, but there are some inconveniences involving temporary files.++<h2>Feedback</h2>++Please provide feedback on the FreeSect <a href="http://www.mail-archive.com/haskell-cafe@haskell.org/msg97643.html">haskell-cafe</a> mailing list thread.+<p>+<div style="margin-top: 30px;">Kind Reg'ds,</div>+<div style="margin-top: 10px;">Andrew Seniuk</div>+<div style="font-size: 10pt; margin-top: 0px;">(rasfar on #haskell)</div>+<div style="font-size: 8pt; margin-top: 8px;"> Feb. 29, 2012</div>++<br />+<br />+</body>+</html>
+ Doc/irc.html view
@@ -0,0 +1,97 @@+<html>+<head>+</style>+</head>+Feb. 22, 2012 -- some omissions and contractions of the literal logs.<br /><br />+<table>+<tr valign="top"><td>00:30:40</td><td><eyebloom></td><td>Instead of f x y z you could write f _ _ z</td></tr>+<tr valign="top"><td>00:31:24</td><td><rasfar></td><td>eyebloom, this is amazing, you have hit upon the language extension I just started implementing an hour ago</td></tr>+<tr valign="top"><td>00:31:45</td><td><rasfar></td><td>underscores and all...</td></tr>+<tr valign="top"><td>00:31:45</td><td><eyebloom></td><td>You know what they say about great minds.</td></tr>+<tr valign="top"><td>00:32:17</td><td><rasfar></td><td>maybe we'll find out whether there's any need.</td></tr>+<tr valign="top"><td>00:33:44</td><td><rasfar></td><td>i was just looking to see if such an extension already exists, but it appears not (so far)</td></tr>+<tr valign="top"><td>00:37:51</td><td><eyebloom></td><td>As syntactic sugar it would be a lot cleaner looking then a lambda a flip or even an explicit infix.</td></tr>+<tr valign="top"><td>00:40:16</td><td><eyebloom></td><td>message me if you start working on this.</td></tr>+<tr valign="top"><td>00:40:26</td><td><rasfar></td><td>fair enough! «email sent»</td></tr>+</table><br /><table>++<tr valign="top"><td>00:31:12</td><td><quintessence></td><td>:t flip</td></tr>+<tr valign="top"><td>00:31:13</td><td><lambdabot></td><td>forall (f :: * -> *) a b. (Functor f) => f (a -> b) -> a -> f b</td></tr>+<tr valign="top"><td>00:32:13</td><td><cmccann></td><td>:t flip . fmap flip</td></tr>+<tr valign="top"><td>00:32:14</td><td><lambdabot></td><td>forall (f :: * -> *) a (f1 :: * -> *) b. (Functor f, Functor f1) => f (f1 (a -> b)) -> a -> f (f1 b)</td></tr>+<tr valign="top"><td>00:32:24</td><td><cmccann></td><td>:t flip . fmap Prelude.flip</td></tr>+<tr valign="top"><td>00:32:28</td><td><lambdabot></td><td>forall (f :: * -> *) a a1 c. (Functor f) => f (a1 -> a -> c) -> a -> f (a1 -> c)</td></tr>+<tr valign="top"><td>00:32:29</td><td><cmccann></td><td>argh</td></tr>+<tr valign="top"><td>00:32:34</td><td><cmccann></td><td>:t flip <<< fmap Prelude.flip</td></tr>+<tr valign="top"><td>00:32:35</td><td><lambdabot></td><td>forall (f :: * -> *) a a1 c. (Functor f) => f (a1 -> a -> c) -> a -> f (a1 -> c)</td></tr>+<tr valign="top"><td>00:32:44</td><td><cmccann></td><td>:t Prelude.flip <<< fmap Prelude.flip</td></tr>+<tr valign="top"><td>00:32:45</td><td><lambdabot></td><td>forall a b a1 c. (a -> a1 -> b -> c) -> b -> a -> a1 -> c</td></tr>+<tr valign="top"><td>00:32:56</td><td><cmccann></td><td>:t Prelude.flip <<< fmap Prelude.flip <<< fmap (fmap Prelude.flip)</td></tr>+<tr valign="top"><td>00:32:56</td><td><lambdabot></td><td>forall a b a1 a2 c. (a -> a1 -> a2 -> b -> c) -> b -> a -> a1 -> a2 -> c</td></tr>+<tr valign="top"><td>00:33:32</td><td>*</td><td>cmccann has a type-hackery generalized flip that does the kind of argument rotation as the above functions</td></tr>+</table><br /><table>++<tr valign="top"><td>00:31:15</td><td><shachaf></td><td>(\x y -> f x y z)</td></tr>+<tr valign="top"><td>00:32:15</td><td><dolio></td><td>Vetoed.</td></tr>+<tr valign="top"><td>00:32:18</td><td><mzero></td><td>if the function takes two arguments, say foo a b and you want to apply the b (leaving a function that takes a) then idiomatic Haskell is to write (`foo` 7)</td></tr>+<tr valign="top"><td>00:32:30</td><td><shachaf></td><td>I second dolio's veto.</td></tr>+<tr valign="top"><td>00:33:44</td><td><mzero></td><td>if you want more, it is idiomatic to use a lambda, which is generally easier than all this flipyness: (\a b -> fixMyThirdArg a b 42)</td></tr>+<tr valign="top"><td>00:34:13</td><td><tikhonjelvis></td><td>flipyness is a good word</td></tr>+<tr valign="top"><td>00:34:22</td><td><mzero></td><td>:-)</td></tr>+<tr valign="top"><td>00:34:24</td><td><eyebloom></td><td>truthiness</td></tr>+<tr valign="top"><td>00:45:43</td><td><mzero></td><td>gosh - I think the rarity of needing to partially apply a function to some argument than the first or second is such that it isn't worth complicating the language at all</td></tr>+<tr valign="top"><td>00:45:55</td><td><mzero></td><td>practically, this just doesn't come up in my code base that often</td></tr>+<tr valign="top"><td>00:47:53</td><td><mzero></td><td>wow - all this to avoid computer science's smallest lambda syntax? rlly?</td></tr>+</table><br /><table>++<tr valign="top"><td>00:46:01</td><td><shachaf></td><td>The obvious solution is to replace every _ with (\x->x).</td></tr>+<tr valign="top"><td>00:46:15</td><td><shachaf></td><td>{-# LANGUAGE CPP #-} #define _ (\x->x)</td></tr>+</table><br /><table>++<tr valign="top"><td>00:36:42</td><td><nand`></td><td>let apFst = id; apSnd = flip; alThd f c = \a b -> f a b c; ...</td></tr>+<tr valign="top"><td>00:36:52</td><td><nand`></td><td>foo `apThd` 42</td></tr>+</table><br /><table>++<tr valign="top"><td>00:38:19</td><td><dolio></td><td>I've used languages with it, and it leads to people writing unclear code.</td></tr>+<tr valign="top"><td>00:38:43</td><td><dolio></td><td>map (foo (g _) x) (h _)</td></tr>+<tr valign="top"><td>00:38:45</td><td>*</td><td>rasfar attends to dolio carefully...</td></tr>+<tr valign="top"><td>00:38:47</td><td><quintessence></td><td>scala?</td></tr>+<tr valign="top"><td>00:38:52</td><td><dolio></td><td>Yes.</td></tr>+<tr valign="top"><td>00:38:51</td><td><glguy_></td><td>Unclear code? Yup, Haskell already supports that</td></tr>+<tr valign="top"><td>00:39:09</td><td><eyebloom></td><td>:) so does every language.</td></tr>+<tr valign="top"><td>00:39:44</td><td><quintessence></td><td>I think the problem in scala is more that it's hard to see the scope of the (implicit) lambda</td></tr>+<tr valign="top"><td>00:40:22</td><td><dolio></td><td>foo (g _) =?= foo $ g _</td></tr>+<tr valign="top"><td>00:40:58</td><td><glguy_></td><td>Factor supports that as a library</td></tr>+<tr valign="top"><td>00:41:06</td><td><quintessence></td><td>Something like (\-> f _ 10 _) would be a little less ambiguous</td></tr>+<tr valign="top"><td>00:41:26</td><td><rwbarton></td><td>Mathematica has this goofy Foo[a, #, c] & syntax</td></tr>+<tr valign="top"><td>00:42:39</td><td><rwbarton></td><td>where & is like quintessence's \-> but in postfix form</td></tr>+<tr valign="top"><td>00:44:27</td><td><dolio></td><td>Matter of fact, what does "map (foo (g _) x) (h _)" mean?</td></tr>+<tr valign="top"><td>00:45:29</td><td><nand`></td><td>\a b -> map (foo (g a) x) (h b) maybe?</td></tr>+<tr valign="top"><td>00:45:48</td><td><shachaf></td><td>How do you figure out where to put the lambda?</td></tr>+<tr valign="top"><td>00:45:55</td><td><nand`></td><td>I didn't. I took a wild guess</td></tr>+<tr valign="top"><td>00:46:01</td><td><nand`></td><td>that's the problem</td></tr>+</table><br /><table>++<tr valign="top"><td>00:46:16</td><td><dolio></td><td>nand`: I can tell you, that's not what the equivalent Scala code means.</td></tr>+<tr valign="top"><td>00:46:30</td><td><rwbarton></td><td>could you show the actual equivalent Scala code?</td></tr>+<tr valign="top"><td>00:46:56</td><td><dolio></td><td>h(_).map(foo(g(_))(x))</td></tr>+<tr valign="top"><td>00:47:21</td><td><glguy_></td><td>it burns us!</td></tr>+<tr valign="top"><td>00:47:27</td><td><dolio></td><td>Drink that in.</td></tr>+<tr valign="top"><td>00:47:30</td><td><nyingen></td><td>urk</td></tr>+<tr valign="top"><td>00:48:06</td><td><dolio></td><td>The foo(g(_)) is something you'd actually use in scala, too.</td></tr>+<tr valign="top"><td>00:48:18</td><td><dolio></td><td>because often times foo(g) would be illegal.</td></tr>+<tr valign="top"><td>00:48:31</td><td><dolio></td><td>So you're stuck with foo(g(_)) or foo(g _)</td></tr>+<tr valign="top"><td>00:49:12</td><td><dolio></td><td>Anyhow it means: a => h(a).map(foo(b => g(b))(x))</td></tr>+<tr valign="top"><td>00:49:52</td><td><dolio></td><td>Or if you kept it as: map(foo(g(_))(x))(h(_)), it'd be: map(foo(a => g(a))(x)(b => h(b)), I believe.</td></tr>+<tr valign="top"><td>00:49:53</td><td><rwbarton></td><td>is that a => (h(a).map(foo(b => g(b))(x))) ?</td></tr>+<tr valign="top"><td>00:50:18</td><td><dolio></td><td>Yes. x => e is a lambda expression in Scala.</td></tr>+</table><br /><table>++<tr valign="top"><td>00:48:52</td><td><quintessence></td><td>I think avoiding the names is the win and avoiding the lambda is the problem</td></tr>+</table><br /><table>++<tr valign="top"><td>00:50:30</td><td><nand`></td><td>\ -> (or more generally, replacing any distinct instance of _ in the right hand side of a lambda by a new identifier which would be appended to the left hand side of the nearest lambda) might work to save you a few keystrokes;</td></tr>+<tr valign="top"><td>00:50:37</td><td><nand`></td><td>but then you run into situations such as nesting those</td></tr>+<tr valign="top"><td>00:52:49</td><td><nand`></td><td>(\a -> f _ 42 _ a) could be assumed equivalent to (\a b c -> f b 42 c a)</td></tr>+</table>+</html>
+ FilesAndParsing.hs view
@@ -0,0 +1,130 @@++-- Package: freesect-0.0.5+-- Executable: freesect+-- Author: Andrew Seniuk <rasfar@gmail.com>+-- Date: March 11, 2012+-- License: BSD3 (./LICENCE)+-- Synopsis: Extend Haskell to support free sections+-- Example: zipWith (f __ b __ d) as bs+-- Usage: See accompanying files 000-readme and z++{-# LANGUAGE CPP #-}++-- CPP definitions are now set using compiler options; see ./z and ./ile.+-- #define ANNOTATED 0++ module FilesAndParsing where++ import Directory++ import Data.Maybe(fromMaybe)++#if ANNOTATED+ import HSE.Annotated+#else+ import HSE+#endif++ import HSE.Extension+++-- Code in this module is rather old, but has worked for me.+-- No doubt there are better libraries I should be using; will+-- fix this up for a subsequent release.++ readSourcesFromFileOrDir :: String -> IO [(String,String)]+ readSourcesFromFileOrDir pathname+ = do dfe <- doesFileExist pathname+ dde <- doesDirectoryExist pathname+ contents <- if dfe+ then+ do conts <- readFile pathname+ return [(pathname,conts)]+ else if dde+ then readDirOfModules pathname+ else error $ "No such file or directory as "+ ++ pathname+ return contents++ -- if got here, the pathname exists and is a directory+ readDirOfModules :: String -> IO [(String,String)]+ readDirOfModules pathname+ = do+ dconts <- getDirectoryContents pathname+ cwd <- getCurrentDirectory+ let+ dconts' = filter isDot dconts+ pathname' = pathname ++ "/"+ dconts'' = map (pathname'++) dconts'+ dconts''' = map (removeDotPathComponent . makeAbsolute cwd) dconts''+ conts <- mapM readFile dconts'''+ return $ zip dconts''' conts++ -- XXX should also clean up ".." components...+ -- This function wasn't done to address any immediate problem+ -- but better to be clean.+ -- This is complicated by certain special cases,+ -- for instance if path was "/here/is./a/path".+ removeDotPathComponent :: String -> String+ removeDotPathComponent ('.':'.':'/':t) = error "path contained .."+ removeDotPathComponent ('.':'/':t) = removeDotPathComponent' t+ removeDotPathComponent x = removeDotPathComponent' x+ removeDotPathComponent' :: String -> String+ removeDotPathComponent' [] = []+ removeDotPathComponent' ('/':'.':'/':t) = removeDotPathComponent' ('/':t)+ removeDotPathComponent' ('/':'.':'.':'/':t) = error "path contained .."+ removeDotPathComponent' (h:t) = h : removeDotPathComponent' t++ makeAbsolute :: String -> String -> String+ makeAbsolute pfx pname+ | null pname = ""+ | head pname == '/' = pname -- already absolute+ | otherwise = pfx ++ "/" ++ pname++ isDot :: String -> Bool+ isDot s+ | length s < 4 = False+ | (take 3 $ reverse s) == "sh." = True+ | otherwise = False++ testParses :: [ParseResult a] -> [a]+ testParses [] = []+ testParses (h:t)+ = ( case h of+ ParseOk x -> x+ ParseFailed x y -> error $ "Parse error:\n" ++ " Location: "+ ++ show x ++ "\n Error: " ++ show y+ ) : testParses t++#if ANNOTATED+ doParsing :: [String] -> [String] -> [ParseResult (Module SrcSpanInfo)]+#else+ doParsing :: [String] -> [String] -> [ParseResult Module]+#endif+ doParsing [] _ = []+ doParsing (a:as) (b:bs)+ = (parseModuleWithMode (myParseMode a b) b) : doParsing as bs++ myParseMode :: String -> String -> ParseMode+ myParseMode fname lexsrc = ParseMode+ {parseFilename = fname+ ,extensions = theExtensions lexsrc+-- ,extensions = knownExtensions -- or you can build explicit sublist+ ,ignoreLanguagePragmas = False+ ,ignoreLinePragmas = True+ ,fixities = Just baseFixities}++ theExtensions :: String -> [Extension]+ theExtensions lexsrc = e+ where+#if ANNOTATED+ e = fromMaybe [] $ readExtensions lexsrc+#else+ -- in retrospect, could probably have used readExtensions here, too?+ a = ( getTopPragmas lexsrc ) :: ParseResult [ModulePragma]+ [b] = ( testParses [a] ) :: [[ModulePragma]]+ c = ( concat ( map (\(LanguagePragma _ ns)->ns) b ) ) :: [Name]+ d = (map (\(Ident s)->s) c) :: [String]+ e = ( map classifyExtension d ) :: [Extension]+#endif+
+ HSE.hs view
@@ -0,0 +1,114 @@+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts+-- Copyright : (c) Niklas Broberg 2004-2009+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- An umbrella module for the various functionality+-- of the package. Also provides some convenient+-- functionality for dealing directly with source files.+--+-----------------------------------------------------------------------------+module HSE (+ -- * Re-exported modules+ module HSE.Syntax+ , module HSE.Build+ , module HSE.Parser+ , module HSE.Pretty+ , module HSE.Extension+ , module HSE.Fixity+ , module HSE.Comments+ -- * Parsing of Haskell source files+ , parseFile+ , parseFileWithMode+ , parseFileWithExts+ , parseFileWithComments+ , parseFileContents+ , parseFileContentsWithMode+ , parseFileContentsWithExts+ , parseFileContentsWithComments+ -- * Read extensions declared in LANGUAGE pragmas+ , readExtensions+ ) where++import HSE.Build+import HSE.Syntax+import HSE.Parser+import HSE.Pretty+import HSE.Extension+import HSE.Fixity+import HSE.Comments++import Data.List+import Language.Preprocessor.Unlit++-- | Parse a source file on disk, using the default parse mode.+parseFile :: FilePath -> IO (ParseResult Module)+parseFile fp = parseFileWithMode (defaultParseMode { parseFilename = fp }) fp++-- | Parse a source file on disk, with an extra set of extensions to know about+-- on top of what the file itself declares.+parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult Module)+parseFileWithExts exts fp = parseFileWithMode (defaultParseMode { extensions = exts, parseFilename = fp }) fp++-- | Parse a source file on disk, supplying a custom parse mode.+parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult Module)+parseFileWithMode p fp = readFile fp >>= (return . parseFileContentsWithMode p)++-- | Parse a source file on disk, supplying a custom parse mode, and retaining comments.+parseFileWithComments :: ParseMode -> FilePath -> IO (ParseResult (Module, [Comment]))+parseFileWithComments p fp = readFile fp >>= (return . parseFileContentsWithComments p)++-- | Parse a source file from a string using the default parse mode.+parseFileContents :: String -> ParseResult Module+parseFileContents = parseFileContentsWithMode defaultParseMode++-- | Parse a source file from a string, with an extra set of extensions to know about+-- on top of what the file itself declares.+parseFileContentsWithExts :: [Extension] -> String -> ParseResult Module+parseFileContentsWithExts exts = parseFileContentsWithMode (defaultParseMode { extensions = exts })++-- | Parse a source file from a string using a custom parse mode.+parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module+parseFileContentsWithMode p@(ParseMode fn exts ign _ _) rawStr =+ let md = delit fn $ ppContents rawStr+ allExts = -- impliesExts $ + case (ign, readExtensions md) of+ (False,Just es) -> exts ++ es+ _ -> exts+ in parseWithMode (p { extensions = allExts }) md++-- | Parse a source file from a string using a custom parse mode and retaining comments.+parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module, [Comment])+parseFileContentsWithComments p@(ParseMode fn exts ign _ _) rawStr =+ let md = delit fn $ ppContents rawStr+ allExts = impliesExts $ case (ign, readExtensions md) of+ (False,Just es) -> exts ++ es+ _ -> exts+ in parseWithComments (p { extensions = allExts }) md+++-- | Gather the extensions declared in LANGUAGE pragmas+-- at the top of the file. Returns 'Nothing' if the+-- parse of the pragmas fails.+readExtensions :: String -> Maybe [Extension]+readExtensions str = case getTopPragmas str of+ ParseOk pgms -> Just (concatMap getExts pgms)+ _ -> Nothing+ where getExts :: ModulePragma -> [Extension]+ getExts (LanguagePragma _ ns) = map readExt ns+ getExts _ = []++ readExt (Ident e) = classifyExtension e++ppContents :: String -> String+ppContents = unlines . f . lines+ where f (('#':_):rest) = rest+ f x = x++delit :: String -> String -> String+delit fn = if ".lhs" `isSuffixOf` fn then unlit fn else id
+ HSE/Annotated.hs view
@@ -0,0 +1,124 @@+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts+-- Copyright : (c) Niklas Broberg 2004-2009+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- An umbrella module for the various functionality+-- of the package. Also provides some convenient+-- functionality for dealing directly with source files.+--+-----------------------------------------------------------------------------+module HSE.Annotated (+ -- * Re-exported modules+ module HSE.Annotated.Syntax+ , module HSE.Annotated.Build+ , module HSE.Parser+ , module HSE.Pretty+ , module HSE.Annotated.Fixity+ , module HSE.Annotated.ExactPrint+ , module HSE.SrcLoc+ , module HSE.Comments+ , module HSE.Extension+ -- * Parsing of Haskell source files+ , parseFile+ , parseFileWithMode+ , parseFileWithExts+ , parseFileWithComments+ , parseFileContents+ , parseFileContentsWithMode+ , parseFileContentsWithExts+ , parseFileContentsWithComments+ -- * Parsing of Haskell source elements,+ , parseModule, parseModuleWithMode, parseModuleWithComments+ , parseExp, parseExpWithMode, parseExpWithComments+ , parseStmt, parseStmtWithMode, parseStmtWithComments+ , parsePat, parsePatWithMode, parsePatWithComments+ , parseDecl, parseDeclWithMode, parseDeclWithComments+ , parseType, parseTypeWithMode, parseTypeWithComments+ -- * Read extensions declared in LANGUAGE pragmas+ , readExtensions+ ) where++import HSE.Annotated.Build+import HSE.Annotated.Syntax+import HSE.Parser ( Parseable(..), ParseResult(..), fromParseResult, ParseMode(..), defaultParseMode )+import HSE.Pretty+import HSE.Annotated.Fixity+import HSE.Annotated.ExactPrint+import HSE.SrcLoc+import HSE.Extension+import HSE.Comments++import HSE.InternalParser++import Data.List+import Language.Preprocessor.Unlit++-- | Parse a source file on disk, using the default parse mode.+parseFile :: FilePath -> IO (ParseResult (Module SrcSpanInfo))+parseFile fp = parseFileWithMode (defaultParseMode { parseFilename = fp }) fp++-- | Parse a source file on disk, with an extra set of extensions to know about+-- on top of what the file itself declares.+parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo))+parseFileWithExts exts fp = parseFileWithMode (defaultParseMode { extensions = exts, parseFilename = fp }) fp++-- | Parse a source file on disk, supplying a custom parse mode.+parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo))+parseFileWithMode p fp = readFile fp >>= (return . parseFileContentsWithMode p)++parseFileWithComments :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment]))+parseFileWithComments p fp = readFile fp >>= (return . parseFileContentsWithComments p)++-- | Parse a source file from a string using the default parse mode.+parseFileContents :: String -> ParseResult (Module SrcSpanInfo)+parseFileContents = parseFileContentsWithMode defaultParseMode++-- | Parse a source file from a string, with an extra set of extensions to know about+-- on top of what the file itself declares.+parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo)+parseFileContentsWithExts exts = parseFileContentsWithMode (defaultParseMode { extensions = exts })++-- | Parse a source file from a string using a custom parse mode.+parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)+parseFileContentsWithMode p@(ParseMode fn exts ign _ _) rawStr =+ let md = delit fn $ ppContents rawStr+ allExts = -- impliesExts $ + case (ign, readExtensions md) of+ (False,Just es) -> exts ++ es+ _ -> exts+ in parseModuleWithMode (p { extensions = allExts }) md++parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])+parseFileContentsWithComments p@(ParseMode fn exts ign _ _) rawStr =+ let md = delit fn $ ppContents rawStr+ allExts = impliesExts $ case (ign, readExtensions md) of+ (False,Just es) -> exts ++ es+ _ -> exts+ in parseModuleWithComments (p { extensions = allExts }) md++-- | Gather the extensions declared in LANGUAGE pragmas+-- at the top of the file. Returns 'Nothing' if the+-- parse of the pragmas fails.+readExtensions :: String -> Maybe [Extension]+readExtensions str = case getTopPragmas str of+ ParseOk pgms -> Just (concatMap getExts pgms)+ _ -> Nothing+ where getExts :: ModulePragma l -> [Extension]+ getExts (LanguagePragma _ ns) = map readExt ns+ getExts _ = []++ readExt (Ident _ e) = classifyExtension e++ppContents :: String -> String+ppContents = unlines . f . lines+ where f (('#':_):rest) = rest+ f x = x++delit :: String -> String -> String+delit fn = if ".lhs" `isSuffixOf` fn then unlit fn else id
+ HSE/Annotated/Build.hs view
@@ -0,0 +1,300 @@+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Annotated.Build+-- Copyright : (c) The GHC Team, 1997-2000,+-- (c) Niklas Broberg 2004+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : experimental+-- Portability : portable+--+-- This module contains combinators to use when building+-- Haskell source trees programmatically, as opposed to+-- parsing them from a string. The contents here are quite+-- experimental and will likely receive a lot of attention+-- when the rest has stabilised.+--+-----------------------------------------------------------------------------++module HSE.Annotated.Build (++ -- * Syntax building functions+ name, -- :: String -> Name+ sym, -- :: String -> Name+ var, -- :: Name -> Exp+ op, -- :: Name -> QOp+ qvar, -- :: Module -> Name -> Exp+ pvar, -- :: Name -> Pat+ app, -- :: Exp -> Exp -> Exp+ infixApp, -- :: Exp -> QOp -> Exp -> Exp+ appFun, -- :: Exp -> [Exp] -> Exp+ pApp, -- :: Name -> [Pat] -> Pat+ tuple, -- :: [Exp] -> Exp+ pTuple, -- :: [Pat] -> Pat+ varTuple, -- :: [Name] -> Exp+ pvarTuple, -- :: [Name] -> Pat+ function, -- :: String -> Exp+ strE, -- :: String -> Exp+ charE, -- :: Char -> Exp+ intE, -- :: Integer -> Exp+ strP, -- :: String -> Pat+ charP, -- :: Char -> Pat+ intP, -- :: Integer -> Pat+ doE, -- :: [Stmt] -> Exp+ lamE, -- :: SrcLoc -> [Pat] -> Exp -> Exp+ letE, -- :: [Decl] -> Exp -> Exp+ caseE, -- :: Exp -> [Alt] -> Exp+ alt, -- :: SrcLoc -> Pat -> Exp -> Alt+ altGW, -- :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt+ listE, -- :: [Exp] -> Exp+ eList, -- :: Exp+ peList, -- :: Pat+ fscontext, -- :: Exp -> Exp+ paren, -- :: Exp -> Exp+ pParen, -- :: Pat -> Pat+ qualStmt, -- :: Exp -> Stmt+ genStmt, -- :: SrcLoc -> Pat -> Exp -> Stmt+ letStmt, -- :: [Decl] -> Stmt+ binds, -- :: [Decl] -> Binds+ noBinds, -- :: Binds+ freeSectSlot, -- :: Exp+ wildcard, -- :: Pat+ genNames, -- :: String -> Int -> [Name]++ -- * More advanced building+ sfun, -- :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl+ simpleFun, -- :: SrcLoc -> Name -> Name -> Exp -> Decl+ patBind, -- :: SrcLoc -> Pat -> Exp -> Decl+ patBindWhere, -- :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl+ nameBind, -- :: SrcLoc -> Name -> Exp -> Decl+ metaFunction, -- :: String -> [Exp] -> Exp+ metaConPat -- :: String -> [Pat] -> Pat+ ) where++import HSE.Annotated.Syntax++-----------------------------------------------------------------------------+-- Help functions for Abstract syntax++-- | An identifier with the given string as its name.+-- The string should be a valid Haskell identifier.+name :: l -> String -> Name l+name = Ident++-- | A symbol identifier. The string should be a valid+-- Haskell symbol identifier.+sym :: l -> String -> Name l+sym = Symbol++-- | A local variable as expression.+var :: l -> Name l -> Exp l+var l = Var l . UnQual l++-- | Use the given identifier as an operator.+op :: l -> Name l -> QOp l+op l = QVarOp l . UnQual l++-- | A qualified variable as expression.+qvar :: l -> ModuleName l -> Name l -> Exp l+qvar l m = Var l . Qual l m++-- | A pattern variable.+pvar :: l -> Name l -> Pat l+pvar = PVar++-- | Application of expressions by juxtaposition.+app :: l -> Exp l -> Exp l -> Exp l+app = App++-- | Apply an operator infix.+infixApp :: l -> Exp l -> QOp l -> Exp l -> Exp l+infixApp = InfixApp++-- | Apply a function to a list of arguments.+appFun :: [l] -> Exp l -> [Exp l] -> Exp l+appFun _ f [] = f+appFun (l:ls) f (a:as) = appFun ls (app l f a) as++-- | A constructor pattern, with argument patterns.+pApp :: l -> Name l -> [Pat l] -> Pat l+pApp l n = PApp l (UnQual l n)++-- | A tuple expression.+tuple :: l -> [Exp l] -> Exp l+tuple = Tuple++-- | A tuple pattern.+pTuple :: l -> [Pat l] -> Pat l+pTuple = PTuple++-- | A tuple expression consisting of variables only.+varTuple :: l -> [Name l] -> Exp l+varTuple l ns = tuple l $ map (var l) ns++-- | A tuple pattern consisting of variables only.+pvarTuple :: l -> [Name l] -> Pat l+pvarTuple l ns = pTuple l $ map (pvar l) ns++-- | A function with a given name.+function :: l -> String -> Exp l+function l = var l . Ident l++-- | A literal string expression.+strE :: l -> String -> Exp l+strE l s = Lit l $ String l s s++-- | A literal character expression.+charE :: l -> Char -> Exp l+charE l c = Lit l $ Char l c [c]++-- | A literal integer expression.+intE :: l -> Integer -> Exp l+intE l i = Lit l $ Int l i (show i)++-- | A literal string pattern.+strP :: l -> String -> Pat l+strP l s = PLit l $ String l s s++-- | A literal character pattern.+charP :: l -> Char -> Pat l+charP l c = PLit l $ Char l c [c]++-- | A literal integer pattern.+intP :: l -> Integer -> Pat l+intP l i = PLit l $ Int l i (show i)++-- | A do block formed by the given statements.+-- The last statement in the list should be+-- a 'Qualifier' expression.+doE :: l -> [Stmt l] -> Exp l+doE = Do++-- | Lambda abstraction, given a list of argument+-- patterns and an expression body.+lamE :: l -> [Pat l] -> Exp l -> Exp l+lamE = Lambda++-- | A @let@ ... @in@ block.+letE :: l -> [Decl l] -> Exp l -> Exp l+letE l ds e = Let l (binds l ds) e++-- | A @case@ expression.+caseE :: l -> Exp l -> [Alt l] -> Exp l+caseE = Case++-- | An unguarded alternative in a @case@ expression.+alt :: l -> Pat l -> Exp l -> Alt l+alt l p e = Alt l p (unGAlt l e) Nothing++-- | An alternative with a single guard in a @case@ expression.+altGW :: l -> Pat l -> [Stmt l] -> Exp l -> Binds l -> Alt l+altGW l p gs e w = Alt l p (gAlt l gs e) (Just w)++-- | An unguarded righthand side of a @case@ alternative.+unGAlt :: l -> Exp l -> GuardedAlts l+unGAlt = UnGuardedAlt++-- | An list of guarded righthand sides for a @case@ alternative.+gAlts :: l -> [([Stmt l], Exp l)] -> GuardedAlts l+gAlts l as = GuardedAlts l $ map (\(gs,e) -> GuardedAlt l gs e) as++-- | A single guarded righthand side for a @case@ alternative.+gAlt :: l -> [Stmt l] -> Exp l -> GuardedAlts l+gAlt l gs e = gAlts l [(gs,e)]++-- | A list expression.+listE :: l -> [Exp l] -> Exp l+listE = List++-- | The empty list expression.+eList :: l -> Exp l+eList l = List l []++-- | The empty list pattern.+peList :: l -> Pat l+peList l = PList l []++-- | Put FreeSect context around an expression.+fscontext :: l -> Exp l -> Exp l+fscontext = FSContext++-- | Put parentheses around an expression.+paren :: l -> Exp l -> Exp l+paren = Paren++-- | Put parentheses around a pattern.+pParen :: l -> Pat l -> Pat l+pParen = PParen++-- | A qualifier expression statement.+qualStmt :: l -> Exp l -> Stmt l+qualStmt = Qualifier++-- | A generator statement: /pat/ @<-@ /exp/+genStmt :: l -> Pat l -> Exp l -> Stmt l+genStmt = Generator++-- | A @let@ binding group as a statement.+letStmt :: l -> [Decl l] -> Stmt l+letStmt l ds = LetStmt l $ binds l ds++-- | Hoist a set of declarations to a binding group.+binds :: l -> [Decl l] -> Binds l+binds = BDecls++-- | An empty binding group.+noBinds :: l -> Binds l+noBinds l = binds l []++-- | FreeSect placeholder: @__@+freeSectSlot :: l -> Exp l+freeSectSlot = FreeSectSlot++-- | The wildcard pattern: @_@+wildcard :: l -> Pat l+wildcard = PWildCard++-- | Generate k names by appending numbers 1 through k to a given string.+genNames :: l -> String -> Int -> [Name l]+genNames l s k = [ Ident l $ s ++ show i | i <- [1..k] ]++-------------------------------------------------------------------------------+-- Some more specialised help functions++-- | A function with a single clause+sfun :: l -> Name l -> [Name l] -> Rhs l -> Maybe (Binds l) -> Decl l+sfun l f pvs rhs mbs = FunBind l [Match l f (map (pvar l) pvs) rhs mbs]++-- | A function with a single clause, a single argument, no guards+-- and no where declarations+simpleFun :: l -> Name l -> Name l -> Exp l -> Decl l+simpleFun l f a e = let rhs = UnGuardedRhs l e+ in sfun l f [a] rhs Nothing++-- | A pattern bind where the pattern is a variable, and where+-- there are no guards and no 'where' clause.+patBind :: l -> Pat l -> Exp l -> Decl l+patBind l p e = let rhs = UnGuardedRhs l e+ in PatBind l p Nothing rhs Nothing++-- | A pattern bind where the pattern is a variable, and where+-- there are no guards, but with a 'where' clause.+patBindWhere :: l -> Pat l -> Exp l -> [Decl l] -> Decl l+patBindWhere l p e ds = let rhs = UnGuardedRhs l e+ in PatBind l p Nothing rhs (Just $ binds l ds)++-- | Bind an identifier to an expression.+nameBind :: l -> Name l -> Exp l -> Decl l+nameBind l n e = patBind l (pvar l n) e++-- | Apply function of a given name to a list of arguments.+metaFunction :: l -> String -> [Exp l] -> Exp l+metaFunction l s es = mf l s (reverse es)+ where mf l s [] = var l $ name l s+ mf l s (e:es) = app l (mf l s es) e++-- | Apply a constructor of a given name to a list of pattern+-- arguments, forming a constructor pattern.+metaConPat :: l -> String -> [Pat l] -> Pat l+metaConPat l s ps = pApp l (name l s) ps
+ HSE/Annotated/ExactPrint.hs view
@@ -0,0 +1,1747 @@+----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Annotated.ExactPrint +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : stable +-- Portability : portable +-- +-- Exact-printer for Haskell abstract syntax. The input is a (semi-concrete) +-- abstract syntax tree, annotated with exact source information to enable +-- printing the tree exactly as it was parsed. +-- +----------------------------------------------------------------------------- +module HSE.Annotated.ExactPrint + ( exactPrint + , ExactP + ) where + +import HSE.Annotated.Syntax +import HSE.SrcLoc +import HSE.Comments + +import Control.Monad (when) +import Control.Arrow ((***), (&&&)) +import Data.List (intersperse) + +-- import Debug.Trace (trace) + +------------------------------------------------------ +-- The EP monad and basic combinators + +type Pos = (Int,Int) + +pos :: (SrcInfo loc) => loc -> Pos +pos ss = (startLine ss, startColumn ss) + +newtype EP x = EP (Pos -> [Comment] -> (x, Pos, [Comment], ShowS)) + +instance Monad EP where + return x = EP $ \l cs -> (x, l, cs, id) + + EP m >>= k = EP $ \l0 c0 -> let + (a, l1, c1, s1) = m l0 c0 + EP f = k a + (b, l2, c2, s2) = f l1 c1 + in (b, l2, c2, s1 . s2) + +runEP :: EP () -> [Comment] -> String +runEP (EP f) cs = let (_,_,_,s) = f (1,1) cs in s "" + +getPos :: EP Pos +getPos = EP (\l cs -> (l,l,cs,id)) + +setPos :: Pos -> EP () +setPos l = EP (\_ cs -> ((),l,cs,id)) + +printString :: String -> EP () +printString str = EP (\(l,c) cs -> ((), (l,c+length str), cs, showString str)) + +getComment :: EP (Maybe Comment) +getComment = EP $ \l cs -> + let x = case cs of + c:_ -> Just c + _ -> Nothing + in (x, l, cs, id) + +dropComment :: EP () +dropComment = EP $ \l cs -> + let cs' = case cs of + (_:cs) -> cs + _ -> cs + in ((), l, cs', id) + +newLine :: EP () +newLine = do + (l,_) <- getPos + printString "\n" + setPos (l+1,1) + +padUntil :: Pos -> EP () +padUntil (l,c) = do + (l1,c1) <- getPos + case {- trace (show ((l,c), (l1,c1))) -} () of + _ {-()-} | l1 >= l && c1 <= c -> printString $ replicate (c - c1) ' ' + | l1 < l -> newLine >> padUntil (l,c) + | otherwise -> return () + + +mPrintComments :: Pos -> EP () +mPrintComments p = do + mc <- getComment + case mc of + Nothing -> return () + Just (Comment multi s str) -> + when (pos s < p) $ do + dropComment + padUntil (pos s) + printComment multi str + setPos (srcSpanEndLine s, srcSpanEndColumn s) + mPrintComments p + +printComment :: Bool -> String -> EP () +printComment b str + | b = printString $ "{-" ++ str ++ "-}" + | otherwise = printString $ "--" ++ str + +printWhitespace :: Pos -> EP () +printWhitespace p = mPrintComments p >> padUntil p + +printStringAt :: Pos -> String -> EP () +printStringAt p str = printWhitespace p >> printString str + +errorEP :: String -> EP a +errorEP = fail + +------------------------------------------------------------------------------ +-- Printing of source elements + +-- | Print an AST exactly as specified by the annotations on the nodes in the tree. +exactPrint :: (ExactP ast) => ast SrcSpanInfo -> [Comment] -> String +exactPrint ast cs = runEP (exactPC ast) cs + +exactPC :: (ExactP ast) => ast SrcSpanInfo -> EP () +exactPC ast = let p = pos (ann ast) in mPrintComments p >> padUntil p >> exactP ast + +printSeq :: [(Pos, EP ())] -> EP () +printSeq [] = return () +printSeq ((p,pr):xs) = printWhitespace p >> pr >> printSeq xs + +printStrs :: SrcInfo loc => [(loc, String)] -> EP () +printStrs = printSeq . map (pos *** printString) + +printPoints :: SrcSpanInfo -> [String] -> EP () +printPoints l = printStrs . zip (srcInfoPoints l) + +printInterleaved, printInterleaved' :: (Annotated ast, ExactP ast, SrcInfo loc) => [(loc, String)] -> [ast SrcSpanInfo] -> EP () +printInterleaved sistrs asts = printSeq $ + interleave (map (pos *** printString ) sistrs) + (map (pos . ann &&& exactP) asts) + +printInterleaved' sistrs (a:asts) = exactPC a >> printInterleaved sistrs asts + +printStreams :: [(Pos, EP ())] -> [(Pos, EP ())] -> EP () +printStreams [] ys = printSeq ys +printStreams xs [] = printSeq xs +printStreams (x@(p1,ep1):xs) (y@(p2,ep2):ys) + | p1 <= p2 = printWhitespace p1 >> ep1 >> printStreams xs (y:ys) + | otherwise = printWhitespace p2 >> ep2 >> printStreams (x:xs) ys + + +interleave :: [a] -> [a] -> [a] +interleave [] ys = ys +interleave xs [] = xs +interleave (x:xs) (y:ys) = x:y: interleave xs ys + +maybeEP :: (a -> EP ()) -> Maybe a -> EP () +maybeEP = maybe (return ()) + +bracketList :: (Annotated ast, ExactP ast) => (String, String, String) -> [SrcSpan] -> [ast SrcSpanInfo] -> EP () +bracketList (a,b,c) poss asts = printInterleaved (pList poss (a,b,c)) asts + +pList (p:ps) (a,b,c) = (p,a) : pList' ps (b,c) +pList' [] _ = [] +pList' [p] (_,c) = [(p,c)] +pList' (p:ps) (b,c) = (p, b) : pList' ps (b,c) + +-- I'm not sure why'd need, but trying to follow Paren behaviour for Exp +-- (because failed to get it working so far folloing XRPats etc.) +fscontextList :: (Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP () +fscontextList = bracketList ("_[",",","]_") + +parenList, squareList, curlyList :: (Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP () +parenList = bracketList ("(",",",")") +squareList = bracketList ("[",",","]") +curlyList = bracketList ("{",",","}") + +layoutList :: (Functor ast, Show (ast ()), Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP () +layoutList poss asts = printStreams + (map (pos *** printString) $ lList poss) + (map (pos . ann &&& exactP) asts) + +lList (p:ps) = (if isNullSpan p then (p,"") else (p,"{")) : lList' ps +lList' [] = [] +lList' [p] = [if isNullSpan p then (p,"") else (p,"}")] +lList' (p:ps) = (if isNullSpan p then (p,"") else (p,";")) : lList' ps + + +-------------------------------------------------- +-- Exact printing + +class Annotated ast => ExactP ast where + exactP :: ast SrcSpanInfo -> EP () + +instance ExactP Literal where + exactP lit = case lit of + Char _ _ rw -> printString ('\'':rw ++ "\'") + String _ _ rw -> printString ('\"':rw ++ "\"") + Int _ _ rw -> printString (rw) + Frac _ _ rw -> printString (rw) + PrimInt _ _ rw -> printString (rw ++ "#" ) + PrimWord _ _ rw -> printString (rw ++ "##") + PrimFloat _ _ rw -> printString (rw ++ "#" ) + PrimDouble _ _ rw -> printString (rw ++ "##") + PrimChar _ _ rw -> printString ('\'':rw ++ "\'#" ) + PrimString _ _ rw -> printString ('\"':rw ++ "\"#" ) + +instance ExactP ModuleName where + exactP (ModuleName l str) = printString str + +instance ExactP SpecialCon where + exactP sc = case sc of + UnitCon l -> printPoints l ["(",")"] + ListCon l -> printPoints l ["[","]"] + FunCon l -> printPoints l ["(","->",")"] + TupleCon l b n -> printPoints l $ + case b of + Unboxed -> "(#": replicate (n-1) "," ++ ["#)"] + _ -> "(" : replicate (n-1) "," ++ [")"] + Cons l -> printString ":" + UnboxedSingleCon l -> printPoints l ["(#","#)"] + +isSymbol :: Name l -> Bool +isSymbol (Symbol _ _) = True +isSymbol _ = False + +getName :: QName l -> Name l +getName (UnQual _ s) = s +getName (Qual _ _ s) = s +getName (Special l (Cons _)) = Symbol l ":" +getName (Special l (FunCon _)) = Symbol l "->" +getName (Special l s) = Ident l (specialName s) + +specialName :: SpecialCon l -> String +specialName (UnitCon _) = "()" +specialName (ListCon _) = "[]" +specialName (FunCon _) = "->" +specialName (TupleCon _ b n) = "(" ++ hash ++ replicate (n-1) ',' ++ hash ++ ")" + where hash = case b of + Unboxed -> "#" + _ -> "" +specialName (Cons _) = ":" + +instance ExactP QName where + exactP qn + | isSymbol (getName qn) = do + case srcInfoPoints (ann qn) of + [a,b,c] -> do + printString "(" + printWhitespace (pos b) + epQName qn + printStringAt (pos c) ")" + _ -> errorEP "ExactP: QName is given wrong number of srcInfoPoints" + | otherwise = epQName qn + +epQName :: QName SrcSpanInfo -> EP () +epQName qn = case qn of + Qual l mn n -> exactP mn >> printString "." >> epName n + UnQual l n -> epName n + Special l sc -> exactP sc + +epInfixQName :: QName SrcSpanInfo -> EP () +epInfixQName qn + | isSymbol (getName qn) = printWhitespace (pos (ann qn)) >> epQName qn + | otherwise = do + case srcInfoPoints (ann qn) of + [a,b,c] -> do + printStringAt (pos a) "`" + printWhitespace (pos b) + epQName qn + printStringAt (pos c) "`" + _ -> errorEP "ExactP: QName (epInfixName) is given wrong number of srcInfoPoints" + +instance ExactP Name where + exactP n = case n of + Ident l str -> printString str + Symbol l str -> do + case srcInfoPoints l of + [a,b,c] -> do + printString "(" + printWhitespace (pos b) + printString str + printStringAt (pos c) ")" + _ -> errorEP "ExactP: Name is given wrong number of srcInfoPoints" + +epName :: Name SrcSpanInfo -> EP () +epName (Ident _ str) = printString str +epName (Symbol _ str) = printString str + +epInfixName :: Name SrcSpanInfo -> EP () +epInfixName n + | isSymbol n = printWhitespace (pos (ann n)) >> epName n + | otherwise = do + case srcInfoPoints (ann n) of + [a,b,c] -> do + printStringAt (pos a) "`" + printWhitespace (pos b) + epName n + printStringAt (pos c) "`" + _ -> errorEP "ExactP: Name (epInfixName) is given wrong number of srcInfoPoints" + +instance ExactP IPName where + exactP ipn = case ipn of + IPDup l str -> printString $ '?':str + IPLin l str -> printString $ '%':str + +instance ExactP QOp where + exactP qop = case qop of + QVarOp l qn -> epInfixQName qn + QConOp l qn -> epInfixQName qn + +instance ExactP Op where + exactP op = case op of + VarOp l n -> epInfixName n + ConOp l n -> epInfixName n + + + +instance ExactP CName where + exactP cn = case cn of + VarName l n -> exactP n + ConName l n -> exactP n + +instance ExactP ExportSpec where + exactP espec = case espec of + EVar l qn -> exactP qn + EAbs l qn -> exactP qn + EThingAll l qn -> exactP qn >> printPoints l ["(","..",")"] + EThingWith l qn cns -> + let k = length (srcInfoPoints l) + in exactP qn >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns + EModuleContents l mn -> printString "module" >> exactPC mn + +instance ExactP ExportSpecList where + exactP (ExportSpecList l ess) = + let k = length (srcInfoPoints l) + in printInterleaved (zip (srcInfoPoints l) $ "(": replicate (k-2) "," ++ [")"]) ess + +instance ExactP ImportSpecList where + exactP (ImportSpecList l hid ispecs) = do + let pts = srcInfoPoints l + pts <- if hid then do + let (x:pts') = pts + printStringAt (pos x) "hiding" + return pts' + else return pts + let k = length pts + printInterleaved (zip pts $ "(": replicate (k-2) "," ++ [")"]) ispecs + +instance ExactP ImportSpec where + exactP ispec = case ispec of + IVar l n -> exactP n + IAbs l n -> exactP n + IThingAll l n -> exactP n >> printPoints l ["(","..",")"] + IThingWith l n cns -> + let k = length (srcInfoPoints l) + in exactP n >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns + +instance ExactP ImportDecl where + exactP (ImportDecl l mn qf src mpkg mas mispecs) = do + printString "import" + case srcInfoPoints l of + (a:pts) -> do + pts <- if src then + case pts of + x:y:pts' -> do + printStringAt (pos x) "{-# SOURCE" + printStringAt (pos y) "#-}" + return pts' + _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints" + else return pts + pts <- if qf then + case pts of + x:pts' -> do + printStringAt (pos x) "qualified" + return pts' + _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints" + else return pts + pts <- case mpkg of + Just pkg -> + case pts of + x:pts' -> do + printStringAt (pos x) $ show pkg + return pts' + _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints" + _ -> return pts + exactPC mn + pts <- case mas of + Just as -> + case pts of + x:pts' -> do + printStringAt (pos x) "as" + exactPC as + return pts' + _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints" + _ -> return pts + case mispecs of + Nothing -> return () + Just ispecs -> exactPC ispecs + _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints" + +instance ExactP Module where + exactP mdl = case mdl of + Module l mmh oss ids decls -> do + let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l) + layoutList oPts oss + maybeEP exactPC mmh + printStreams (map (pos *** printString) $ lList pts) + (map (pos . ann &&& exactPC) ids ++ map (pos . ann &&& exactPC) (sepFunBinds decls)) + XmlPage l _mn oss xn attrs mat es -> do + let (oPts, pPts) = splitAt (max (length oss + 1) 2) $ srcInfoPoints l + case pPts of + [a,b,c,d,e] -> do + layoutList oPts oss + printStringAt (pos a) "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) ">" + mapM_ exactPC es + printStringAt (pos c) "</" + printWhitespace (pos d) + exactP xn + printStringAt (pos e) ">" + _ -> errorEP "ExactP: Module: XmlPage is given wrong number of srcInfoPoints" + XmlHybrid l mmh oss ids decls xn attrs mat es -> do + let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l) + layoutList oPts oss + maybeEP exactPC mmh + let (dPts, pPts) = splitAt (length pts - 5) pts + case pPts of + [a,b,c,d,e] -> do + printStreams (map (\(p,s) -> (pos p, printString s)) $ lList dPts) + (map (\i -> (pos $ ann i, exactPC i)) ids ++ map (\d -> (pos $ ann d, exactPC d)) (sepFunBinds decls)) + + printStringAt (pos a) "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) ">" + mapM_ exactPC es + printStringAt (pos c) "</" + printWhitespace (pos d) + exactP xn + printStringAt (pos e) ">" + _ -> errorEP "ExactP: Module: XmlHybrid is given wrong number of srcInfoPoints" + +instance ExactP ModuleHead where + exactP (ModuleHead l mn mwt mess) = do + case srcInfoPoints l of + [a,b] -> do + printStringAt (pos a) "module" + exactPC mn + maybeEP exactPC mwt + maybeEP exactPC mess + printStringAt (pos b) "where" + _ -> errorEP "ExactP: ModuleHead is given wrong number of srcInfoPoints" + +instance ExactP ModulePragma where + exactP op = case op of + LanguagePragma l ns -> + let pts = srcInfoPoints l + k = length ns - 1 -- number of commas + m = length pts - k - 2 -- number of virtual semis, likely 0 + in printInterleaved (zip pts ("{-# LANGUAGE":replicate k "," ++ replicate m "" ++ ["#-}"])) ns + OptionsPragma l mt str -> + let k = length (srcInfoPoints l) + opstr = "{-# OPTIONS" ++ case mt of { Just t -> "_" ++ show t ; _ -> "" } ++ " " ++ str + in printPoints l $ opstr : replicate (k-2) "" ++ ["#-}"] + AnnModulePragma l ann -> + case srcInfoPoints l of + [a,b] -> do + printString $ "{-# ANN" + exactPC ann + printStringAt (pos b) "#-}" + _ -> errorEP "ExactP: ModulePragma: AnnPragma is given wrong number of srcInfoPoints" + +instance ExactP WarningText where + exactP (DeprText l str) = printPoints l ["{-# DEPRECATED", str, "#-}"] + exactP (WarnText l str) = printPoints l ["{-# WARNING", str, "#-}"] + +instance ExactP Assoc where + exactP a = case a of + AssocNone l -> printString "infix" + AssocLeft l -> printString "infixl" + AssocRight l -> printString "infixr" + +instance ExactP DataOrNew where + exactP (DataType l) = printString "data" + exactP (NewType l) = printString "newtype" + +instance ExactP Decl where + exactP decl = case decl of + TypeDecl l dh t -> + case srcInfoPoints l of + [a,b] -> do + printStringAt (pos a) "type" + exactPC dh + printStringAt (pos b) "=" + exactPC t + _ -> errorEP "ExactP: Decl: TypeDecl is given wrong number of srcInfoPoints" + TypeFamDecl l dh mk -> + case srcInfoPoints l of + a:b:ps -> do + printStringAt (pos a) "type" + printStringAt (pos b) "family" + exactPC dh + maybeEP (\k -> printStringAt (pos (head ps)) "::" >> exactPC k) mk + _ -> errorEP "ExactP: Decl: TypeFamDecl is given wrong number of srcInfoPoints" + DataDecl l dn mctxt dh constrs mder -> do + exactP dn + maybeEP exactPC mctxt + exactPC dh + -- the next line works for empty data types since the srcInfoPoints will be empty then + printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs + maybeEP exactPC mder + GDataDecl l dn mctxt dh mk gds mder -> do + let pts = srcInfoPoints l + exactP dn + maybeEP exactPC mctxt + exactPC dh + pts <- case mk of + Nothing -> return pts + Just kd -> case pts of + p:pts' -> do + printStringAt (pos p) "::" + exactPC kd + return pts' + _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints" + case pts of + x:pts -> do + printStringAt (pos x) "where" + layoutList pts gds + maybeEP exactPC mder + _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints" + DataFamDecl l mctxt dh mk -> do + printString "data" + maybeEP exactPC mctxt + exactPC dh + maybeEP (\kd -> printStringAt (pos (head (srcInfoPoints l))) "::" >> exactPC kd) mk + TypeInsDecl l t1 t2 -> + case srcInfoPoints l of + [a,b,c] -> do + printString "type" + printStringAt (pos b) "instance" + exactPC t1 + printStringAt (pos c) "=" + exactPC t2 + _ -> errorEP "ExactP: Decl: TypeInsDecl is given wrong number of srcInfoPoints" + DataInsDecl l dn t constrs mder -> + case srcInfoPoints l of + p:pts -> do + exactP dn + printStringAt (pos p) "instance" + exactPC t + printInterleaved (zip pts ("=": repeat "|")) constrs + maybeEP exactPC mder + _ -> errorEP "ExactP: Decl: DataInsDecl is given too few srcInfoPoints" + GDataInsDecl l dn t mk gds mder -> + case srcInfoPoints l of + p:pts -> do + exactP dn + printStringAt (pos p) "instance" + exactPC t + pts <- case mk of + Nothing -> return pts + Just kd -> case pts of + p:pts' -> do + printStringAt (pos p) "::" + exactPC kd + return pts' + _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints" + case pts of + x:pts -> do + printStringAt (pos x) "where" + layoutList pts gds + maybeEP exactPC mder + _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints" + _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints" + ClassDecl l mctxt dh fds mcds -> + case srcInfoPoints l of + a:pts -> do + printString "class" + maybeEP exactPC mctxt + exactPC dh + pts <- case fds of + [] -> return pts + _ -> do + let (pts1, pts2) = splitAt (length fds) pts + printInterleaved (zip pts1 ("|":repeat ",")) fds + return pts2 + maybeEP (\cds -> + case pts of + p:pts' -> do + printStringAt (pos p) "where" + layoutList pts' $ sepClassFunBinds cds + _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints" + ) mcds + _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints" + InstDecl l mctxt ih mids -> + case srcInfoPoints l of + a:pts -> do + printString "instance" + maybeEP exactPC mctxt + exactPC ih + maybeEP (\ids -> do + let (p:pts') = pts + printStringAt (pos p) "where" + layoutList pts' $ sepInstFunBinds ids + ) mids + _ -> errorEP "ExactP: Decl: InstDecl is given too few srcInfoPoints" + DerivDecl l mctxt ih -> + case srcInfoPoints l of + [a,b] -> do + printString "deriving" + printStringAt (pos b) "instance" + maybeEP exactPC mctxt + exactPC ih + _ -> errorEP "ExactP: Decl: DerivDecl is given wrong number of srcInfoPoints" + InfixDecl l assoc mprec ops -> do + let pts = srcInfoPoints l + exactP assoc + pts <- case mprec of + Nothing -> return pts + Just prec -> + case pts of + p:pts' -> do + printStringAt (pos p) (show prec) + return pts' + _ -> errorEP "ExactP: Decl: InfixDecl is given too few srcInfoPoints" + printInterleaved' (zip pts (repeat ",")) ops + DefaultDecl l ts -> + case srcInfoPoints l of + a:pts -> do + printString "default" + printInterleaved (zip (init pts) ("(":repeat ",")) ts + printStringAt (pos (last pts)) ")" + _ -> errorEP "ExactP: Decl: DefaultDecl is given too few srcInfoPoints" + SpliceDecl l spl -> exactP spl + TypeSig l ns t -> do + let pts = srcInfoPoints l + printInterleaved' (zip pts (replicate (length pts - 1) "," ++ ["::"])) ns + exactPC t + FunBind l ms -> mapM_ exactPC ms + PatBind l p mt rhs mbs -> do + let pts = srcInfoPoints l + exactP p + pts <- case mt of + Nothing -> return pts + Just t -> case pts of + x:pts'-> do + printStringAt (pos x) "::" + exactPC t + return pts' + _ -> errorEP "ExactP: Decl: PatBind is given too few srcInfoPoints" + exactPC rhs + maybeEP (\bs -> printStringAt (pos (head pts)) "where" >> exactPC bs) mbs + ForImp l cc msf mstr n t -> + case srcInfoPoints l of + a:b:pts -> do + printString "foreign" + printStringAt (pos b) "import" + exactPC cc + maybeEP exactPC msf + pts <- case mstr of + Nothing -> return pts + Just str -> case pts of + x:pts' -> do + printStringAt (pos x) (show str) + return pts' + _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints" + case pts of + y:_ -> do + exactPC n + printStringAt (pos y) "::" + exactPC t + _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints" + _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints" + ForExp l cc mstr n t -> + case srcInfoPoints l of + a:b:pts -> do + printString "foreign" + printStringAt (pos b) "export" + exactPC cc + pts <- case mstr of + Nothing -> return pts + Just str -> case pts of + x:pts' -> do + printStringAt (pos x) (show str) + return pts' + _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints" + case pts of + y:_ -> do + exactPC n + printStringAt (pos y) "::" + exactPC t + _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints" + _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints" + RulePragmaDecl l rs -> + case srcInfoPoints l of + [a,b] -> do + printString "{-# RULES" + mapM_ exactPC rs + printStringAt (pos b) "#-}" + _ -> errorEP "ExactP: Decl: RulePragmaDecl is given too few srcInfoPoints" + DeprPragmaDecl l nstrs -> + case srcInfoPoints l of + a:pts -> do + printString "{-# DEPRECATED" + printWarndeprs (map pos (init pts)) nstrs + printStringAt (pos (last pts)) "#-}" + _ -> errorEP "ExactP: Decl: DeprPragmaDecl is given too few srcInfoPoints" + WarnPragmaDecl l nstrs -> + case srcInfoPoints l of + a:pts -> do + printString "{-# WARNING" + printWarndeprs (map pos (init pts)) nstrs + printStringAt (pos (last pts)) "#-}" + _ -> errorEP "ExactP: Decl: WarnPragmaDecl is given too few srcInfoPoints" + InlineSig l inl mact qn -> + case srcInfoPoints l of + [a,b] -> do + printString $ if inl then "{-# INLINE" else "{-# NOINLINE" + maybeEP exactPC mact + exactPC qn + printStringAt (pos b) "#-}" + _ -> errorEP "ExactP: Decl: InlineSig is given wrong number of srcInfoPoints" + InlineConlikeSig l mact qn -> + case srcInfoPoints l of + [a,b] -> do + printString "{-# INLINE_CONLIKE" + maybeEP exactPC mact + exactPC qn + printStringAt (pos b) "#-}" + _ -> errorEP "ExactP: Decl: InlineConlikeSig is given wrong number of srcInfoPoints" + SpecSig l qn ts -> + case srcInfoPoints l of + a:pts -> do + printString "{-# SPECIALISE" + exactPC qn + printInterleaved (zip pts ("::" : repeat "," ++ ["#-}"])) ts + _ -> errorEP "ExactP: Decl: SpecSig is given too few srcInfoPoints" + SpecInlineSig l b mact qn ts -> + case srcInfoPoints l of + a:pts -> do + printString $ "{-# SPECIALISE " ++ if b then "INLINE" else "NOINLINE" + maybeEP exactPC mact + exactPC qn + printInterleaved (zip pts ("::" : repeat "," ++ ["#-}"])) ts + _ -> errorEP "ExactP: Decl: SpecInlineSig is given too few srcInfoPoints" + InstSig l mctxt ih -> + case srcInfoPoints l of + [a,b,c] -> do + printString $ "{-# SPECIALISE" + printStringAt (pos b) "instance" + maybeEP exactPC mctxt + exactPC ih + printStringAt (pos c) "#-}" + _ -> errorEP "ExactP: Decl: InstSig is given wrong number of srcInfoPoints" + AnnPragma l ann -> + case srcInfoPoints l of + [a,b] -> do + printString $ "{-# ANN" + exactPC ann + printStringAt (pos b) "#-}" + _ -> errorEP "ExactP: Decl: AnnPragma is given wrong number of srcInfoPoints" + + +instance ExactP Annotation where + exactP ann = case ann of + Ann l n e -> do + exactP n + exactPC e + TypeAnn l n e -> do + printString "type" + exactPC n + exactPC e + ModuleAnn l e -> do + printString "module" + exactPC e + +printWarndeprs :: [Pos] -> [([Name SrcSpanInfo], String)] -> EP () +printWarndeprs _ [] = return () +printWarndeprs ps ((ns,str):nsts) = printWd ps ns str nsts + where printWd :: [Pos] -> [Name SrcSpanInfo] -> String -> [([Name SrcSpanInfo], String)] -> EP () + printWd (p:ps) [] str nsts = printStringAt p (show str) >> printWarndeprs ps nsts + printWd ps [n] str nsts = exactPC n >> printWd ps [] str nsts + printWd (p:ps) (n:ns) str nsts = exactPC n >> printStringAt p "," >> printWd ps ns str nsts + + +sepFunBinds :: [Decl SrcSpanInfo] -> [Decl SrcSpanInfo] +sepFunBinds [] = [] +sepFunBinds (FunBind _ ms:ds) = map (\m -> FunBind (ann m) [m]) ms ++ sepFunBinds ds +sepFunBinds (d:ds) = d : sepFunBinds ds + +sepClassFunBinds :: [ClassDecl SrcSpanInfo] -> [ClassDecl SrcSpanInfo] +sepClassFunBinds [] = [] +sepClassFunBinds (ClsDecl _ (FunBind _ ms):ds) = map (\m -> ClsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepClassFunBinds ds +sepClassFunBinds (d:ds) = d : sepClassFunBinds ds + +sepInstFunBinds :: [InstDecl SrcSpanInfo] -> [InstDecl SrcSpanInfo] +sepInstFunBinds [] = [] +sepInstFunBinds (InsDecl _ (FunBind _ ms):ds) = map (\m -> InsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepInstFunBinds ds +sepInstFunBinds (d:ds) = d : sepInstFunBinds ds + +instance ExactP DeclHead where + exactP dh = case dh of + DHead l n tvs -> exactP n >> mapM_ exactPC tvs + DHInfix l tva n tvb -> exactP tva >> epInfixName n >> exactPC tvb + DHParen l dh -> + case srcInfoPoints l of + [_,b] -> printString "(" >> exactPC dh >> printStringAt (pos b) ")" + _ -> errorEP "ExactP: DeclHead: DeclParen is given wrong number of srcInfoPoints" + +instance ExactP InstHead where + exactP ih = case ih of + IHead l qn ts -> exactP qn >> mapM_ exactPC ts + IHInfix l ta qn tb -> exactP ta >> epInfixQName qn >> exactPC tb + IHParen l ih -> + case srcInfoPoints l of + [_,b] -> printString "(" >> exactPC ih >> printStringAt (pos b) ")" + _ -> errorEP "ExactP: InstHead: IHParen is given wrong number of srcInfoPoints" + +instance ExactP TyVarBind where + exactP (KindedVar l n k) = + case srcInfoPoints l of + [a,b,c] -> do + printString "(" + exactPC n + printStringAt (pos b) "::" + exactPC k + printStringAt (pos c) ")" + _ -> errorEP "ExactP: TyVarBind: KindedVar is given wrong number of srcInfoPoints" + exactP (UnkindedVar l n) = exactP n + +instance ExactP Kind where + exactP kd = case kd of + KindStar l -> printString "*" + KindBang l -> printString "!" + KindFn l k1 k2 -> + case srcInfoPoints l of + [a] -> do + exactP k1 + printStringAt (pos a) "->" + exactPC k2 + _ -> errorEP "ExactP: Kind: KindFn is given wrong number of srcInfoPoints" + KindParen l kd -> do + case srcInfoPoints l of + [a,b] -> do + printString "(" + exactPC kd + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Kind: KindParen is given wrong number of srcInfoPoints" + KindVar l n -> exactP n + +instance ExactP Type where + exactP t = case t of + TyForall l mtvs mctxt t -> do + let pts = srcInfoPoints l + pts <- case mtvs of + Nothing -> return pts + Just tvs -> + case pts of + a:b:pts' -> do + printString "forall" + mapM_ exactPC tvs + printStringAt (pos b) "." + return pts' + _ -> errorEP "ExactP: Type: TyForall is given too few srcInfoPoints" + maybeEP exactPC mctxt + exactPC t + TyFun l t1 t2 -> do + case srcInfoPoints l of + [a] -> do + exactP t1 + printStringAt (pos a) "->" + exactPC t2 + _ -> errorEP "ExactP: Type: TyFun is given wrong number of srcInfoPoints" + TyTuple l bx ts -> do + let pts = srcInfoPoints l + (o,e) = case bx of + Boxed -> ("(" , ")") + Unboxed -> ("(#","#)") + printInterleaved (zip pts (o: replicate (length pts - 2) "," ++ [e])) ts + TyList l t -> do + case srcInfoPoints l of + [a,b] -> do + printString "[" + exactPC t + printStringAt (pos b) "]" + _ -> errorEP "ExactP: Type: TyList is given wrong number of srcInfoPoints" + TyApp l t1 t2 -> exactP t1 >> exactPC t2 + TyVar l n -> exactP n + TyCon l qn -> exactP qn + TyParen l t -> do + case srcInfoPoints l of + [a,b] -> do + printString "(" + exactPC t + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Type: TyParen is given wrong number of srcInfoPoints" + TyInfix l t1 qn t2 -> exactP t1 >> epInfixQName qn >> exactPC t2 + TyKind l t kd -> do + case srcInfoPoints l of + [a,b,c] -> do + printString "(" + exactPC t + printStringAt (pos b) "::" + exactPC kd + printStringAt (pos c) ")" + _ -> errorEP "ExactP: Type: TyKind is given wrong number of srcInfoPoints" + +instance ExactP Context where + exactP ctxt = do + printContext ctxt + printStringAt (pos . last . srcInfoPoints . ann $ ctxt) "=>" + +printContext ctxt = do + let l = ann ctxt + pts = init $ srcInfoPoints l + case ctxt of + CxParen l ctxt -> + case pts of + [a,b] -> do + printStringAt (pos a) "(" + printContext ctxt + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Context: CxParen is given wrong number of srcInfoPoints" + CxSingle l asst -> exactP asst + CxEmpty l -> + case pts of + [a,b] -> do + printStringAt (pos a) "(" + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Context: CxEmpty is given wrong number of srcInfoPoints" + CxTuple l assts -> parenList pts assts + + +instance ExactP Asst where + exactP asst = case asst of + ClassA l qn ts -> exactP qn >> mapM_ exactPC ts + InfixA l ta qn tb -> exactP ta >> epInfixQName qn >> exactPC tb + IParam l ipn t -> + case srcInfoPoints l of + [a] -> do + exactP ipn + printStringAt (pos a) "::" + exactPC t + _ -> errorEP "ExactP: Asst: IParam is given wrong number of srcInfoPoints" + EqualP l t1 t2 -> + case srcInfoPoints l of + [a] -> do + exactP t1 + printStringAt (pos a) "~" + exactPC t2 + +instance ExactP Deriving where + exactP (Deriving l ihs) = + case srcInfoPoints l of + x:pts -> do + printString "deriving" + case pts of + [] -> exactPC $ head ihs + _ -> parenList pts ihs + _ -> errorEP "ExactP: Deriving is given too few srcInfoPoints" + +instance ExactP ClassDecl where + exactP cdecl = case cdecl of + ClsDecl l d -> exactP d + ClsDataFam l mctxt dh mk -> + case srcInfoPoints l of + x:pts -> do + printString "data" + maybeEP exactPC mctxt + exactPC dh + maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk + _ -> errorEP "ExactP: ClassDecl: ClsDataFam is given too few srcInfoPoints" + ClsTyFam l dh mk -> + case srcInfoPoints l of + x:pts -> do + printString "type" + exactPC dh + maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk + _ -> errorEP "ExactP: ClassDecl: ClsTyFam is given too few srcInfoPoints" + ClsTyDef l t1 t2 -> + case srcInfoPoints l of + a:b:pts -> do + printString "type" + exactPC t1 + printStringAt (pos b) "=" + exactPC t2 + _ -> errorEP "ExactP: ClassDecl: ClsTyDef is given too few srcInfoPoints" + +instance ExactP InstDecl where + exactP idecl = case idecl of + InsDecl l d -> exactP d + InsType l t1 t2 -> + case srcInfoPoints l of + [a,b] -> do + printString "type" + exactPC t1 + printStringAt (pos b) "=" + exactPC t2 + InsData l dn t constrs mder -> do + exactP dn + exactPC t + printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs + maybeEP exactPC mder + InsGData l dn t mk gds mder -> do + let pts = srcInfoPoints l + exactP dn + exactPC t + pts <- case mk of + Nothing -> return pts + Just kd -> case pts of + p:pts' -> do + printStringAt (pos p) "::" + exactPC kd + return pts' + _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints" + case pts of + x:_ -> do + printStringAt (pos x) "where" + mapM_ exactPC gds + maybeEP exactPC mder + _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints" +-- InsInline l inl mact qn -> do +-- case srcInfoPoints l of +-- [a,b] -> do +-- printString $ if inl then "{-# INLINE" else "{-# NOINLINE" +-- maybeEP exactPC mact +-- exactPC qn +-- printStringAt (pos b) "#-}" +-- _ -> errorEP "ExactP: InstDecl: InsInline is given wrong number of srcInfoPoints" + +instance ExactP FunDep where + exactP (FunDep l nxs nys) = + case srcInfoPoints l of + [a] -> do + mapM_ exactPC nxs + printStringAt (pos a) "->" + mapM_ exactPC nys + _ -> errorEP "ExactP: FunDep is given wrong number of srcInfoPoints" + +instance ExactP QualConDecl where + exactP (QualConDecl l mtvs mctxt cd) = do + let pts = srcInfoPoints l + pts <- case mtvs of + Nothing -> return pts + Just tvs -> + case pts of + a:b:pts' -> do + printString "forall" + mapM_ exactPC tvs + printStringAt (pos b) "." + return pts' + _ -> errorEP "ExactP: QualConDecl is given wrong number of srcInfoPoints" + maybeEP exactPC mctxt + exactPC cd + +instance ExactP ConDecl where + exactP cd = case cd of + ConDecl l n bts -> exactP n >> mapM_ exactPC bts + InfixConDecl l bta n btb -> exactP bta >> epInfixName n >> exactP btb + RecDecl l n fds -> exactP n >> curlyList (srcInfoPoints l) fds + +instance ExactP GadtDecl where + exactP (GadtDecl l n t) = + case srcInfoPoints l of + [a] -> do + exactP n + printStringAt (pos a) "::" + exactPC t + _ -> errorEP "ExactP: GadtDecl is given wrong number of srcInfoPoints" + +instance ExactP BangType where + exactP bt = case bt of + UnBangedTy l t -> exactP t + BangedTy l t -> printString "!" >> exactPC t + UnpackedTy l t -> + case srcInfoPoints l of + [a,b,c] -> do + printString "{-# UNPACK" + printStringAt (pos b) "#-}" + printStringAt (pos c) "!" + exactPC t + _ -> errorEP "ExactP: BangType: UnpackedTy is given wrong number of srcInfoPoints" + +instance ExactP Splice where + exactP (IdSplice l str) = printString $ '$':str + exactP (ParenSplice l e) = + case srcInfoPoints l of + [a,b] -> do + printString "$(" + exactPC e + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Splice: ParenSplice is given wrong number of srcInfoPoints" + +instance ExactP Exp where + exactP exp = case exp of + Var l qn -> exactP qn + FreeSectSlot l -> printString "__" + IPVar l ipn -> exactP ipn + Con l qn -> exactP qn + Lit l lit -> exactP lit + InfixApp l e1 op e2 -> exactP e1 >> exactPC op >> exactPC e2 + App l e1 e2 -> exactP e1 >> exactPC e2 + NegApp l e -> printString "-" >> exactPC e + Lambda l ps e -> + case srcInfoPoints l of + [a,b] -> do + printString "\\" + mapM_ exactPC ps + printStringAt (pos b) "->" + exactPC e + _ -> errorEP "ExactP: Exp: Lambda is given wrong number of srcInfoPoints" + Let l bs e -> + case srcInfoPoints l of + [a,b] -> do + printString "let" + exactPC bs + printStringAt (pos b) "in" + exactPC e + _ -> errorEP "ExactP: Exp: Let is given wrong number of srcInfoPoints" + If l ec et ee -> + case srcInfoPoints l of + [a,b,c] -> do + printString "if" + exactPC ec + printStringAt (pos b) "then" + exactPC et + printStringAt (pos c) "else" + exactPC ee + _ -> errorEP "ExactP: Exp: If is given wrong number of srcInfoPoints" + Case l e alts -> + case srcInfoPoints l of + a:b:pts -> do + printString "case" + exactPC e + printStringAt (pos b) "of" + layoutList pts alts + _ -> errorEP "ExactP: Exp: Case is given too few srcInfoPoints" + Do l stmts -> + case srcInfoPoints l of + a:pts -> do + printString "do" + layoutList pts stmts + _ -> errorEP "ExactP: Exp: Do is given too few srcInfoPoints" + MDo l stmts -> + case srcInfoPoints l of + a:pts -> do + printString "mdo" + layoutList pts stmts + _ -> errorEP "ExactP: Exp: Mdo is given wrong number of srcInfoPoints" + Tuple l es -> parenList (srcInfoPoints l) es + TupleSection l mexps -> do + let pts = srcInfoPoints l + printSeq $ interleave (zip (map pos $ init pts) (map printString ("(": repeat ",")) ++ [(pos $ last pts, printString ")")]) + (map (maybe (0,0) (pos . ann) &&& maybeEP exactPC) mexps) + List l es -> squareList (srcInfoPoints l) es + FSContext l p -> fscontextList (srcInfoPoints l) [p] + Paren l p -> parenList (srcInfoPoints l) [p] + LeftSection l e qop -> + case srcInfoPoints l of + [a,b] -> do + printString "(" + exactPC e + exactPC qop + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Exp: LeftSection is given wrong number of srcInfoPoints" + RightSection l qop e -> + case srcInfoPoints l of + [a,b] -> do + printString "(" + exactPC qop + exactPC e + printStringAt (pos b) ")" + _ -> errorEP "ExactP: Exp: RightSection is given wrong number of srcInfoPoints" + RecConstr l qn fups -> do + let pts = srcInfoPoints l + exactP qn + curlyList pts fups + RecUpdate l e fups -> do + let pts = srcInfoPoints l + exactP e + curlyList pts fups + EnumFrom l e -> + case srcInfoPoints l of + [a,b,c] -> do + printString "[" + exactPC e + printStringAt (pos b) ".." + printStringAt (pos c) "]" + _ -> errorEP "ExactP: Exp: EnumFrom is given wrong number of srcInfoPoints" + EnumFromTo l e1 e2 -> + case srcInfoPoints l of + [a,b,c] -> do + printString "[" + exactPC e1 + printStringAt (pos b) ".." + exactPC e2 + printStringAt (pos c) "]" + _ -> errorEP "ExactP: Exp: EnumFromTo is given wrong number of srcInfoPoints" + EnumFromThen l e1 e2 -> + case srcInfoPoints l of + [a,b,c,d] -> do + printString "[" + exactPC e1 + printStringAt (pos b) "," + exactPC e2 + printStringAt (pos c) ".." + printStringAt (pos d) "]" + _ -> errorEP "ExactP: Exp: EnumFromThen is given wrong number of srcInfoPoints" + EnumFromThenTo l e1 e2 e3 -> + case srcInfoPoints l of + [a,b,c,d] -> do + printString "[" + exactPC e1 + printStringAt (pos b) "," + exactPC e2 + printStringAt (pos c) ".." + exactPC e3 + printStringAt (pos d) "]" + _ -> errorEP "ExactP: Exp: EnumFromToThen is given wrong number of srcInfoPoints" + ListComp l e qss -> + case srcInfoPoints l of + a:pts -> do + printString "[" + exactPC e + bracketList ("|",",","]") pts qss + _ -> errorEP "ExactP: Exp: ListComp is given too few srcInfoPoints" + ParComp l e qsss -> + case srcInfoPoints l of + a:pts -> do + let (strs, qss) = unzip $ pairUp qsss + printString "[" + exactPC e + printInterleaved (zip pts (strs ++ ["]"])) qss + _ -> errorEP "ExactP: Exp: ParComp is given wrong number of srcInfoPoints" + where pairUp [] = [] + pairUp ((a:as):xs) = ("|", a) : zip (repeat ",") as ++ pairUp xs + + ExpTypeSig l e t -> + case srcInfoPoints l of + [a] -> do + exactP e + printStringAt (pos a) "::" + exactPC t + _ -> errorEP "ExactP: Exp: ExpTypeSig is given wrong number of srcInfoPoints" + VarQuote l qn -> do + printString "'" + exactPC qn + TypQuote l qn -> do + printString "''" + exactPC qn + BracketExp l br -> exactP br + SpliceExp l sp -> exactP sp + QuasiQuote l name qt -> do + let qtLines = lines qt + printString $ "[$" ++ name ++ "|" + sequence_ (intersperse newLine $ map printString qtLines) + printString "|]" + XTag l xn attrs mat es -> + case srcInfoPoints l of + [a,b,c,d,e] -> do + printString "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) ">" + mapM_ exactPC es + printStringAt (pos c) "</" + printWhitespace (pos d) + exactP xn + printStringAt (pos e) ">" + _ -> errorEP "ExactP: Exp: XTag is given wrong number of srcInfoPoints" + XETag l xn attrs mat -> + case srcInfoPoints l of + [a,b] -> do + printString "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) "/>" + _ -> errorEP "ExactP: Exp: XETag is given wrong number of srcInfoPoints" + XPcdata l str -> do + let strLines = lines str + sequence_ (intersperse newLine $ map printString strLines) + XExpTag l e -> + case srcInfoPoints l of + [a,b] -> do + printString "<%" + exactPC e + printStringAt (pos b) "%>" + _ -> errorEP "ExactP: Exp: XExpTag is given wrong number of srcInfoPoints" + XChildTag l es -> + case srcInfoPoints l of + [a,b,c] -> do + printString "<%>" + mapM_ exactPC es + printStringAt (pos b) "</" + printStringAt (pos c) "%>" + + CorePragma l str e -> + case srcInfoPoints l of + [a,b] -> do + printString $ "{-# CORE " ++ show str + printStringAt (pos b) "#-}" + exactPC e + _ -> errorEP "ExactP: Exp: CorePragma is given wrong number of srcInfoPoints" + SCCPragma l str e -> + case srcInfoPoints l of + [a,b] -> do + printString $ "{-# SCC " ++ show str + printStringAt (pos b) "#-}" + exactPC e + _ -> errorEP "ExactP: Exp: SCCPragma is given wrong number of srcInfoPoints" + GenPragma l str (i1,i2) (i3,i4) e -> do + printStrs $ zip (srcInfoPoints l) ["{-# GENERATED", show str, show i1, ":", show i2, "-", show i3, ":", show i4, "#-}"] + exactPC e + Proc l p e -> + case srcInfoPoints l of + [a,b] -> do + printString "proc" + exactPC p + printStringAt (pos b) "->" + exactPC e + _ -> errorEP "ExactP: Exp: Proc is given wrong number of srcInfoPoints" + LeftArrApp l e1 e2 -> + case srcInfoPoints l of + [a] -> do + exactP e1 + printStringAt (pos a) "-<" + exactPC e2 + _ -> errorEP "ExactP: Exp: LeftArrApp is given wrong number of srcInfoPoints" + RightArrApp l e1 e2 -> do + case srcInfoPoints l of + [a] -> do + exactP e1 + printStringAt (pos a) ">-" + exactPC e2 + _ -> errorEP "ExactP: Exp: RightArrApp is given wrong number of srcInfoPoints" + LeftArrHighApp l e1 e2 -> do + case srcInfoPoints l of + [a] -> do + exactP e1 + printStringAt (pos a) "-<<" + exactPC e2 + _ -> errorEP "ExactP: Exp: LeftArrHighApp is given wrong number of srcInfoPoints" + RightArrHighApp l e1 e2 -> do + case srcInfoPoints l of + [a] -> do + exactP e1 + printStringAt (pos a) ">>-" + exactPC e2 + _ -> errorEP "ExactP: Exp: RightArrHighApp is given wrong number of srcInfoPoints" + +instance ExactP FieldUpdate where + exactP fup = case fup of + FieldUpdate l qn e -> do + case srcInfoPoints l of + [a] -> do + exactP qn + printStringAt (pos a) "=" + exactPC e + _ -> errorEP "ExactP: FieldUpdate is given wrong number of srcInfoPoints" + FieldPun l n -> exactP n + FieldWildcard l -> printString ".." + +instance ExactP Stmt where + exactP stmt = case stmt of + Generator l p e -> + case srcInfoPoints l of + [a] -> do + exactP p + printStringAt (pos a) "<-" + exactPC e + _ -> errorEP "ExactP: Stmt: Generator is given wrong number of srcInfoPoints" + Qualifier l e -> exactP e + LetStmt l bds -> do + printString "let" + exactPC bds + RecStmt l ss -> + case srcInfoPoints l of + a:pts -> do + printString "rec" + layoutList pts ss + _ -> errorEP "ExactP: Stmt: RecStmt is given too few srcInfoPoints" + +instance ExactP QualStmt where + exactP qstmt = case qstmt of + QualStmt l stmt -> exactP stmt + ThenTrans l e -> printString "then" >> exactPC e + ThenBy l e1 e2 -> do + case srcInfoPoints l of + [a,b] -> do + printString "then" + exactPC e1 + printStringAt (pos b) "by" + exactPC e2 + _ -> errorEP "ExactP: QualStmt: ThenBy is given wrong number of srcInfoPoints" + GroupBy l e -> do + printStrs $ zip (srcInfoPoints l) ["then","group","by"] + exactPC e + GroupUsing l e -> do + printStrs $ zip (srcInfoPoints l) ["then","group","using"] + exactPC e + GroupByUsing l e1 e2 -> do + let pts = srcInfoPoints l + printStrs $ zip (init pts) ["then","group","by"] + exactPC e1 + printStringAt (pos (last pts)) "using" + exactPC e2 + +instance ExactP Bracket where + exactP br = case br of +{- This is TH-specific stuff. + FSContext l e -> + case srcInfoPoints l of + [a,b] -> do + printString "_[" + exactPC e + printStringAt (pos b) "]_" + _ -> errorEP "ExactP: Bracket: FSContext is given wrong number of srcInfoPoints" +-} + ExpBracket l e -> + case srcInfoPoints l of + [a,b] -> do + printString "[|" + exactPC e + printStringAt (pos b) "|]" + _ -> errorEP "ExactP: Bracket: ExpBracket is given wrong number of srcInfoPoints" + PatBracket l p -> + case srcInfoPoints l of + [a,b] -> do + printString "[p|" + exactPC p + printStringAt (pos b) "|]" + _ -> errorEP "ExactP: Bracket: PatBracket is given wrong number of srcInfoPoints" + TypeBracket l t -> do + case srcInfoPoints l of + [a,b] -> do + printString "[t|" + exactPC t + printStringAt (pos b) "|]" + _ -> errorEP "ExactP: Bracket: TypeBracket is given wrong number of srcInfoPoints" + DeclBracket l ds -> + case srcInfoPoints l of + a:pts -> do + printString "[d|" + layoutList (init pts) (sepFunBinds ds) + printStringAt (pos (last pts)) "|]" + _ -> errorEP "ExactP: Bracket: DeclBracket is given too few srcInfoPoints" + +instance ExactP XAttr where + exactP (XAttr l xn e) = + case srcInfoPoints l of + [a] -> do + exactP xn + printStringAt (pos a) "=" + exactPC e + _ -> errorEP "ExactP: XAttr is given wrong number of srcInfoPoints" + +instance ExactP Alt where + exactP (Alt l p galts mbs) = do + exactP p + exactPC galts + maybeEP (\bs -> printStringAt (pos (head (srcInfoPoints l))) "where" >> exactPC bs) mbs + +instance ExactP GuardedAlts where + exactP (UnGuardedAlt l e) = printString "->" >> exactPC e + exactP (GuardedAlts l galts) = mapM_ exactPC galts + +instance ExactP GuardedAlt where + exactP (GuardedAlt l stmts e) = do + bracketList ("|",",","->") (srcInfoPoints l) stmts + exactPC e + +instance ExactP Match where + exactP (Match l n ps rhs mbinds) = do + let pts = srcInfoPoints l + len = length pts + pars = len `div` 2 + (oPars,cParsWh) = splitAt pars pts + (cPars,whPt) = splitAt pars cParsWh -- whPt is either singleton or empty + printStrs (zip oPars (repeat "(")) + exactPC n + printStreams (zip (map pos cPars) (repeat $ printString ")")) (map (pos . ann &&& exactPC) ps) + exactPC rhs + maybeEP (\bds -> printStringAt (pos (head pts)) "where" >> exactPC bds) mbinds + exactP (InfixMatch l a n bs rhs mbinds) = do + let pts = srcInfoPoints l + len = length pts + pars = len `div` 2 + (oPars,cParsWh) = splitAt pars pts + (cPars,whPt) = splitAt pars cParsWh -- whPt is either singleton or empty + printStrs (zip oPars (repeat "(")) + exactPC a + epInfixName n + printInterleaved' (zip cPars (repeat ")")) bs + exactPC rhs + maybeEP (\bds -> printStringAt (pos (head whPt)) "where" >> exactPC bds) mbinds + +instance ExactP Rhs where + exactP (UnGuardedRhs l e) = printString "=" >> exactPC e + exactP (GuardedRhss l grhss) = mapM_ exactPC grhss + +instance ExactP GuardedRhs where + exactP (GuardedRhs l ss e) = + case srcInfoPoints l of + a:pts -> do + printString "|" + printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "=")]) ss + exactPC e + _ -> errorEP "ExactP: GuardedRhs is given wrong number of srcInfoPoints" + +instance ExactP Pat where + exactP pat = case pat of + PVar l n -> exactP n + PLit l lit -> exactP lit + PNeg l p -> printString "-" >> exactPC p + PNPlusK l n k -> + case srcInfoPoints l of + [a,b] -> do + exactP n + printStringAt (pos a) "+" + printStringAt (pos b) (show k) + _ -> errorEP "ExactP: Pat: PNPlusK is given wrong number of srcInfoPoints" + PInfixApp l pa qn pb -> exactP pa >> epInfixQName qn >> exactPC pb + PApp l qn ps -> exactP qn >> mapM_ exactPC ps + PTuple l ps -> parenList (srcInfoPoints l) ps + PList l ps -> squareList (srcInfoPoints l) ps + PParen l p -> parenList (srcInfoPoints l) [p] + PRec l qn pfs -> exactP qn >> curlyList (srcInfoPoints l) pfs + PAsPat l n p -> + case srcInfoPoints l of + [a] -> do + exactP n + printStringAt (pos a) "@" + exactPC p + _ -> errorEP "ExactP: Pat: PAsPat is given wrong number of srcInfoPoints" + PWildCard l -> printString "_" + PIrrPat l p -> printString "~" >> exactPC p + PatTypeSig l p t -> + case srcInfoPoints l of + [a] -> do + exactP p + printStringAt (pos a) "::" + exactPC t + _ -> errorEP "ExactP: Pat: PatTypeSig is given wrong number of srcInfoPoints" + PViewPat l e p -> + case srcInfoPoints l of + [a] -> do + exactP e + printStringAt (pos a) "->" + exactPC p + _ -> errorEP "ExactP: Pat: PViewPat is given wrong number of srcInfoPoints" + PRPat l rps -> squareList (srcInfoPoints l) rps + PXTag l xn attrs mat ps -> + case srcInfoPoints l of + [a,b,c,d,e] -> do + printString "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) ">" + mapM_ exactPC ps + printStringAt (pos c) "</" + printWhitespace (pos d) + exactP xn + printStringAt (pos e) ">" + _ -> errorEP "ExactP: Pat: PXTag is given wrong number of srcInfoPoints" + PXETag l xn attrs mat -> + case srcInfoPoints l of + [a,b] -> do + printString "<" + exactPC xn + mapM_ exactPC attrs + maybeEP exactPC mat + printStringAt (pos b) "/>" + _ -> errorEP "ExactP: Pat: PXETag is given wrong number of srcInfoPoints" + PXPcdata l str -> printString str + PXPatTag l p -> + case srcInfoPoints l of + [a,b] -> do + printString "<%" + exactPC p + printString "%>" + _ -> errorEP "ExactP: Pat: PXPatTag is given wrong number of srcInfoPoints" + PXRPats l rps -> bracketList ("<[",",","]>") (srcInfoPoints l) rps + PExplTypeArg l qn t -> + case srcInfoPoints l of + [a,b] -> do + exactP qn + printStringAt (pos a) "{|" + exactPC t + printStringAt (pos b) "|}" + _ -> errorEP "ExactP: Pat: PExplTypeArg is given wrong number of srcInfoPoints" + PQuasiQuote l name qt -> printString $ "[$" ++ name ++ "|" ++ qt ++ "]" + PBangPat l p -> printString "!" >> exactPC p + +instance ExactP PatField where + exactP pf = case pf of + PFieldPat l qn p -> + case srcInfoPoints l of + [a] -> do + exactP qn + printStringAt (pos a) "=" + exactPC p + _ -> errorEP "ExactP: PatField: PFieldPat is given wrong number of srcInfoPoints" + PFieldPun l n -> exactP n + PFieldWildcard l -> printString ".." + +instance ExactP RPat where + exactP rpat = case rpat of + RPOp l rp op -> exactP rp >> exactPC op + RPEither l r1 r2 -> + case srcInfoPoints l of + [a] -> do + exactP r1 + printStringAt (pos a) "|" + exactPC r2 + _ -> errorEP "ExactP: RPat: RPEither is given wrong number of srcInfoPoints" + RPSeq l rps -> bracketList ("(|",",","|)") (srcInfoPoints l) rps + RPGuard l p stmts -> + case srcInfoPoints l of + a:pts -> do + printString "(|" + exactPC p + bracketList ("|",",","|)") pts stmts + _ -> errorEP "ExactP: RPat: RPGuard is given wrong number of srcInfoPoints" + RPCAs l n rp -> + case srcInfoPoints l of + [a] -> do + exactP n + printStringAt (pos a) "@:" + exactPC rp + _ -> errorEP "ExactP: RPat: RPCAs is given wrong number of srcInfoPoints" + RPAs l n rp -> + case srcInfoPoints l of + [a] -> do + exactP n + printStringAt (pos a) "@" + exactPC rp + _ -> errorEP "ExactP: RPat: RPAs is given wrong number of srcInfoPoints" + RPParen l rp -> do + parenList (srcInfoPoints l) [rp] + RPPat l p -> exactP p + +instance ExactP RPatOp where + exactP rop = printString $ case rop of + RPStar l -> "*" + RPStarG l -> "*!" + RPPlus l -> "+" + RPPlusG l -> "+!" + RPOpt l -> "?" + RPOptG l -> "?!" + +instance ExactP PXAttr where + exactP (PXAttr l xn p) = + case srcInfoPoints l of + [a] -> do + exactP xn + printStringAt (pos a) "=" + exactPC p + _ -> errorEP "ExactP: PXAttr is given wrong number of srcInfoPoints" + +instance ExactP XName where + exactP xn = case xn of + XName l name -> printString name + XDomName l dom name -> + case srcInfoPoints l of + [a,b,c] -> do + printString dom + printStringAt (pos b) ":" + printStringAt (pos c) name + _ -> errorEP "ExactP: XName: XDomName is given wrong number of srcInfoPoints" + +instance ExactP Binds where + exactP (BDecls l ds) = layoutList (srcInfoPoints l) (sepFunBinds ds) + exactP (IPBinds l ips) = layoutList (srcInfoPoints l) ips + +instance ExactP CallConv where + exactP (StdCall _) = printString "stdcall" + exactP (CCall _) = printString "ccall" + +instance ExactP Safety where + exactP (PlayRisky _) = printString "unsafe" + exactP (PlaySafe _ b) = printString $ if b then "threadsafe" else "safe" + +instance ExactP Rule where + exactP (Rule l str mact mrvs e1 e2) = + case srcInfoPoints l of + a:pts -> do + printString (show str) + maybeEP exactP mact + pts <- case mrvs of + Nothing -> return pts + Just rvs -> + case pts of + a:b:pts' -> do + printStringAt (pos a) "forall" + mapM_ exactPC rvs + printStringAt (pos b) "." + return pts' + _ -> errorEP "ExactP: Rule is given too few srcInfoPoints" + case pts of + [x] -> do + exactPC e1 + printStringAt (pos x) "=" + exactPC e2 + _ -> errorEP "ExactP: Rule is given wrong number of srcInfoPoints" + _ -> errorEP "ExactP: Rule is given too few srcInfoPoints" + +instance ExactP RuleVar where + exactP (TypedRuleVar l n t) = do + case srcInfoPoints l of + [a,b,c] -> do + printString "(" + exactPC n + printStringAt (pos b) "::" + exactPC t + printStringAt (pos c) ")" + _ -> errorEP "ExactP: RuleVar: TypedRuleVar is given wrong number of srcInfoPoints" + exactP (RuleVar l n) = exactP n + +instance ExactP Activation where + exactP (ActiveFrom l i) = + printPoints l ["[", show i, "]"] + exactP (ActiveUntil l i) = + printPoints l ["[", "~", show i, "]"] + +instance ExactP FieldDecl where + exactP (FieldDecl l ns bt) = do + let pts = srcInfoPoints l + printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "::")]) ns + exactPC bt + +instance ExactP IPBind where + exactP (IPBind l ipn e) = do + case srcInfoPoints l of + [a] -> do + exactP ipn + printStringAt (pos a) "=" + exactPC e + _ -> errorEP "ExactP: IPBind is given wrong number of srcInfoPoints"
+ HSE/Annotated/Fixity.hs view
@@ -0,0 +1,342 @@+----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Annotated.Fixity +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : stable +-- Portability : portable +-- +-- Fixity information to give the parser so that infix operators can +-- be parsed properly. +-- +----------------------------------------------------------------------------- +module HSE.Annotated.Fixity + ( + -- * Fixity representation + Fixity(..) + -- | The following three functions all create lists of + -- fixities from textual representations of operators. + -- The intended usage is e.g. + -- + -- > fixs = infixr_ 0 ["$","$!","`seq`"] + -- + -- Note that the operators are expected as you would + -- write them infix, i.e. with ` characters surrounding + -- /varid/ operators, and /varsym/ operators written as is. + , infix_, infixl_, infixr_ + -- ** Collections of fixities + , preludeFixities, baseFixities + + -- * Applying fixities to an AST + , AppFixity(..) + ) where + +import HSE.Annotated.Syntax +import HSE.SrcLoc + +import HSE.Fixity ( Fixity(..), infix_, infixl_, infixr_, preludeFixities, baseFixities ) +import qualified HSE.Syntax as S ( Assoc(..), QOp(..), Op(..), QName(..), Name(..), SpecialCon(..), ModuleName ) +import HSE.Annotated.Simplify ( sQOp, sOp, sAssoc, sQName, sModuleHead, sName ) + +import Data.Char (isUpper) +import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4) +import Data.Traversable (mapM) +import Prelude hiding (mapM) + +-- | All AST elements that may include expressions which in turn may +-- need fixity tweaking will be instances of this class. +class AppFixity ast where + -- | Tweak any expressions in the element to account for the + -- fixities given. Assumes that all operator expressions are + -- fully left associative chains to begin with. + applyFixities :: Monad m => [Fixity] -- ^ The fixities to account for. + -> ast SrcSpanInfo -- ^ The element to tweak. + -> m (ast SrcSpanInfo) -- ^ The same element, but with operator expressions updated, or a failure. + + +instance AppFixity Exp where + applyFixities fixs = infFix fixs <=< leafFix fixs + where -- This is the real meat case. We can assume a left-associative list to begin with. + infFix fixs (InfixApp l2 a op2 z) = do + e <- infFix fixs a + case e of + InfixApp l1 x op1 y -> do + let (a1,p1) = askFixity fixs op1 + (a2,p2) = askFixity fixs op2 + when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone )) -- Ambiguous infix expression! + $ fail "Ambiguous infix expression" + if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order + then return $ InfixApp l2 e op2 z + else liftM (InfixApp l2 x op1) (infFix fixs $ InfixApp (ann y <++> ann z) y op2 z) + _ -> return $ InfixApp l2 e op2 z + + infFix _ e = return e + +instance AppFixity Pat where + applyFixities fixs = infFix fixs <=< leafFixP fixs + where -- This is the real meat case. We can assume a left-associative list to begin with. + infFix fixs (PInfixApp l2 a op2 z) = do + p <- infFix fixs a + case p of + PInfixApp l1 x op1 y -> do + let (a1,p1) = askFixityP fixs op1 + (a2,p2) = askFixityP fixs op2 + when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone )) -- Ambiguous infix expression! + $ fail "Ambiguous infix expression" + if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order + then return $ PInfixApp l2 p op2 z + else liftM (PInfixApp l2 x op1) (infFix fixs $ PInfixApp (ann y <++> ann z) y op2 z) + _ -> return $ PInfixApp l2 p op2 z + + infFix _ p = return p + +-- Internal: lookup associativity and precedence of an operator +askFixity :: [Fixity] -> QOp l -> (S.Assoc, Int) +askFixity xs k = askFix xs (f $ sQOp k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp + where + f (S.QVarOp x) = g x + f (S.QConOp x) = g x + + g (S.Special S.Cons) = S.UnQual (S.Symbol ":") + g x = x + +-- Same using patterns +askFixityP :: [Fixity] -> QName l -> (S.Assoc, Int) +askFixityP xs qn = askFix xs (g $ sQName qn) + where + g (S.Special S.Cons) = S.UnQual (S.Symbol ":") + g x = x + +askFix :: [Fixity] -> S.QName -> (S.Assoc, Int) +askFix xs = \k -> lookupWithDefault (S.AssocLeft, 9) k mp + where + lookupWithDefault def k mp = case lookup k mp of + Nothing -> def + Just x -> x + + mp = [(x,(a,p)) | Fixity a p x <- xs] + + +------------------------------------------------------------------- +-- Boilerplate - yuck!! Everything below here is internal stuff + +instance AppFixity Module where + applyFixities fixs (Module l mmh prs imp decls) = + liftM (Module l mmh prs imp) $ appFixDecls (Just mn) fixs decls + where (mn, _, _) = sModuleHead mmh + applyFixities fixs (XmlPage l mn os xn xas mexp cs) = + liftM3 (XmlPage l mn os xn) (fix xas) (fix mexp) (fix cs) + where fix xs = mapM (applyFixities fixs) xs + applyFixities fixs (XmlHybrid l mmh prs imp decls xn xas mexp cs) = + liftM4 (flip (XmlHybrid l mmh prs imp) xn) (appFixDecls (Just mn) fixs decls) + (fixe xas) (fixe mexp) (fixe cs) + where fixe xs = let extraFixs = getFixities (Just mn) decls + in mapM (applyFixities (fixs++extraFixs)) xs + (mn, _, _) = sModuleHead mmh + +instance AppFixity Decl where + applyFixities fixs decl = case decl of + ClassDecl l ctxt dh deps cdecls -> liftM (ClassDecl l ctxt dh deps) $ mapM (mapM fix) cdecls + InstDecl l ctxt ih idecls -> liftM (InstDecl l ctxt ih) $ mapM (mapM fix) idecls + SpliceDecl l spl -> liftM (SpliceDecl l) $ fix spl + FunBind l matches -> liftM (FunBind l) $ mapM fix matches + PatBind l p mt rhs bs -> liftM3 (flip (PatBind l) mt) (fix p) (fix rhs) (mapM fix bs) + AnnPragma l ann -> liftM (AnnPragma l) $ fix ann + _ -> return decl + where fix x = applyFixities fixs x + +appFixDecls :: Monad m => Maybe S.ModuleName -> [Fixity] -> [Decl SrcSpanInfo] -> m [Decl SrcSpanInfo] +appFixDecls mmdl fixs decls = + let extraFixs = getFixities mmdl decls + in mapM (applyFixities (fixs++extraFixs)) decls + +getFixities mmdl = concatMap (getFixity mmdl) +getFixity mmdl (InfixDecl _ a mp ops) = let p = maybe 9 id mp in map (Fixity (sAssoc a) p) (concatMap g ops) + where g (VarOp l x) = f $ sName x + g (ConOp l x) = f $ sName x + f x = case mmdl of + Nothing -> [ S.UnQual x] + Just m -> [S.Qual m x, S.UnQual x] +getFixity _ _ = [] + +instance AppFixity Annotation where + applyFixities fixs ann = case ann of + Ann l n e -> liftM (Ann l n) $ fix e + TypeAnn l n e -> liftM (TypeAnn l n) $ fix e + ModuleAnn l e -> liftM (ModuleAnn l) $ fix e + where fix x = applyFixities fixs x + +instance AppFixity ClassDecl where + applyFixities fixs (ClsDecl l decl) = liftM (ClsDecl l) $ applyFixities fixs decl + applyFixities _ cdecl = return cdecl + +instance AppFixity InstDecl where + applyFixities fixs (InsDecl l decl) = liftM (InsDecl l) $ applyFixities fixs decl + applyFixities _ idecl = return idecl + +instance AppFixity Match where + applyFixities fixs match = case match of + Match l n ps rhs bs -> liftM3 (Match l n) (mapM fix ps) (fix rhs) (mapM fix bs) + InfixMatch l a n ps rhs bs -> liftM4 (flip (InfixMatch l) n) (fix a) (mapM fix ps) (fix rhs) (mapM fix bs) + where fix x = applyFixities fixs x + +instance AppFixity Rhs where + applyFixities fixs rhs = case rhs of + UnGuardedRhs l e -> liftM (UnGuardedRhs l) $ fix e + GuardedRhss l grhss -> liftM (GuardedRhss l) $ mapM fix grhss + where fix x = applyFixities fixs x + +instance AppFixity GuardedRhs where + applyFixities fixs (GuardedRhs l stmts e) = liftM2 (GuardedRhs l) (mapM fix stmts) $ fix e + where fix x = applyFixities fixs x + +instance AppFixity PatField where + applyFixities fixs (PFieldPat l n p) = liftM (PFieldPat l n) $ applyFixities fixs p + applyFixities _ pf = return pf + +instance AppFixity RPat where + applyFixities fixs rp = case rp of + RPOp l rp op -> liftM (flip (RPOp l) op) $ fix rp + RPEither l a b -> liftM2 (RPEither l) (fix a) (fix b) + RPSeq l rps -> liftM (RPSeq l) $ mapM fix rps + RPGuard l p stmts -> liftM2 (RPGuard l) (fix p) $ mapM fix stmts + RPCAs l n rp -> liftM (RPCAs l n) $ fix rp + RPAs l n rp -> liftM (RPAs l n) $ fix rp + RPParen l rp -> liftM (RPParen l) $ fix rp + RPPat l p -> liftM (RPPat l) $ fix p + where fix x = applyFixities fixs x + +instance AppFixity PXAttr where + applyFixities fixs (PXAttr l n p) = liftM (PXAttr l n) $ applyFixities fixs p + +instance AppFixity Stmt where + applyFixities fixs stmt = case stmt of + Generator l p e -> liftM2 (Generator l) (fix p) (fix e) + Qualifier l e -> liftM (Qualifier l) $ fix e + LetStmt l bs -> liftM (LetStmt l) $ fix bs -- special behavior + RecStmt l stmts -> liftM (RecStmt l) $ mapM fix stmts + where fix x = applyFixities fixs x + +instance AppFixity Binds where + applyFixities fixs bs = case bs of + BDecls l decls -> liftM (BDecls l) $ appFixDecls Nothing fixs decls -- special behavior + IPBinds l ips -> liftM (IPBinds l) $ mapM fix ips + where fix x = applyFixities fixs x + + +instance AppFixity IPBind where + applyFixities fixs (IPBind l n e) = liftM (IPBind l n) $ applyFixities fixs e + +instance AppFixity FieldUpdate where + applyFixities fixs (FieldUpdate l n e) = liftM (FieldUpdate l n) $ applyFixities fixs e + applyFixities _ fup = return fup + +instance AppFixity Alt where + applyFixities fixs (Alt l p galts bs) = liftM3 (Alt l) (fix p) (fix galts) (mapM fix bs) + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlts where + applyFixities fixs galts = case galts of + UnGuardedAlt l e -> liftM (UnGuardedAlt l) $ fix e + GuardedAlts l galts -> liftM (GuardedAlts l) $ mapM fix galts + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlt where + applyFixities fixs (GuardedAlt l stmts e) = liftM2 (GuardedAlt l) (mapM fix stmts) (fix e) + where fix x = applyFixities fixs x + +instance AppFixity QualStmt where + applyFixities fixs qstmt = case qstmt of + QualStmt l s -> liftM (QualStmt l) $ fix s + ThenTrans l e -> liftM (ThenTrans l) $ fix e + ThenBy l e1 e2 -> liftM2 (ThenBy l) (fix e1) (fix e2) + GroupBy l e -> liftM (GroupBy l) (fix e) + GroupUsing l e -> liftM (GroupUsing l) (fix e) + GroupByUsing l e1 e2 -> liftM2 (GroupByUsing l) (fix e1) (fix e2) + where fix x = applyFixities fixs x + +instance AppFixity Bracket where + applyFixities fixs br = case br of + ExpBracket l e -> liftM (ExpBracket l) $ fix e + PatBracket l p -> liftM (PatBracket l) $ fix p + DeclBracket l ds -> liftM (DeclBracket l) $ mapM fix ds + _ -> return br + where fix x = applyFixities fixs x + +instance AppFixity Splice where + applyFixities fixs (ParenSplice l e) = liftM (ParenSplice l) $ applyFixities fixs e + applyFixities _ s = return s + +instance AppFixity XAttr where + applyFixities fixs (XAttr l n e) = liftM (XAttr l n) $ applyFixities fixs e + + +-- the boring boilerplate stuff for expressions too +-- Recursively fixes the "leaves" of the infix chains, +-- without yet touching the chain itself. We assume all chains are +-- left-associate to begin with. +leafFix fixs e = case e of + InfixApp l e1 op e2 -> liftM2 (flip (InfixApp l) op) (leafFix fixs e1) (fix e2) + App l e1 e2 -> liftM2 (App l) (fix e1) (fix e2) + NegApp l e -> liftM (NegApp l) $ fix e + Lambda l pats e -> liftM2 (Lambda l) (mapM fix pats) $ fix e + Let l bs e -> liftM2 (Let l) (fix bs) $ fix e + If l e a b -> liftM3 (If l) (fix e) (fix a) (fix b) + Case l e alts -> liftM2 (Case l) (fix e) $ mapM fix alts + Do l stmts -> liftM (Do l) $ mapM fix stmts + MDo l stmts -> liftM (MDo l) $ mapM fix stmts + Tuple l exps -> liftM (Tuple l) $ mapM fix exps + List l exps -> liftM (List l) $ mapM fix exps + FSContext l e -> liftM (FSContext l) $ fix e + Paren l e -> liftM (Paren l) $ fix e + LeftSection l e op -> liftM (flip (LeftSection l) op) (fix e) + RightSection l op e -> liftM (RightSection l op) $ fix e + RecConstr l n fups -> liftM (RecConstr l n) $ mapM fix fups + RecUpdate l e fups -> liftM2 (RecUpdate l) (fix e) $ mapM fix fups + EnumFrom l e -> liftM (EnumFrom l) $ fix e + EnumFromTo l e1 e2 -> liftM2 (EnumFromTo l) (fix e1) (fix e2) + EnumFromThen l e1 e2 -> liftM2 (EnumFromThen l) (fix e1) (fix e2) + EnumFromThenTo l e1 e2 e3 -> liftM3 (EnumFromThenTo l) (fix e1) (fix e2) (fix e3) + ListComp l e quals -> liftM2 (ListComp l) (fix e) $ mapM fix quals + ParComp l e qualss -> liftM2 (ParComp l) (fix e) $ mapM (mapM fix) qualss + ExpTypeSig l e t -> liftM (flip (ExpTypeSig l) t) (fix e) + BracketExp l b -> liftM (BracketExp l) $ fix b + SpliceExp l s -> liftM (SpliceExp l) $ fix s + XTag l n ats mexp cs -> liftM3 (XTag l n) (mapM fix ats) (mapM fix mexp) (mapM fix cs) + XETag l n ats mexp -> liftM2 (XETag l n) (mapM fix ats) (mapM fix mexp) + XExpTag l e -> liftM (XExpTag l) $ fix e + XChildTag l cs -> liftM (XChildTag l) $ mapM fix cs + Proc l p e -> liftM2 (Proc l) (fix p) (fix e) + LeftArrApp l e1 e2 -> liftM2 (LeftArrApp l) (fix e1) (fix e2) + RightArrApp l e1 e2 -> liftM2 (RightArrApp l) (fix e1) (fix e2) + LeftArrHighApp l e1 e2 -> liftM2 (LeftArrHighApp l) (fix e1) (fix e2) + RightArrHighApp l e1 e2 -> liftM2 (RightArrHighApp l) (fix e1) (fix e2) + CorePragma l s e -> liftM (CorePragma l s) (fix e) + SCCPragma l s e -> liftM (SCCPragma l s) (fix e) + GenPragma l s ab cd e -> liftM (GenPragma l s ab cd) (fix e) + + _ -> return e + where + fix x = applyFixities fixs x + +leafFixP fixs p = case p of + PNeg l p -> liftM (PNeg l) $ fix p + PApp l n ps -> liftM (PApp l n) $ mapM fix ps + PTuple l ps -> liftM (PTuple l) $ mapM fix ps + PList l ps -> liftM (PList l) $ mapM fix ps + PParen l p -> liftM (PParen l) $ fix p + PRec l n pfs -> liftM (PRec l n) $ mapM fix pfs + PAsPat l n p -> liftM (PAsPat l n) $ fix p + PIrrPat l p -> liftM (PIrrPat l) $ fix p + PatTypeSig l p t -> liftM (flip (PatTypeSig l) t) (fix p) + PViewPat l e p -> liftM2 (PViewPat l) (fix e) (fix p) + PRPat l rps -> liftM (PRPat l) $ mapM fix rps + PXTag l n ats mp ps -> liftM3 (PXTag l n) (mapM fix ats) (mapM fix mp) (mapM fix ps) + PXETag l n ats mp -> liftM2 (PXETag l n) (mapM fix ats) (mapM fix mp) + PXPatTag l p -> liftM (PXPatTag l) $ fix p + PXRPats l rps -> liftM (PXRPats l) $ mapM fix rps + PBangPat l p -> liftM (PBangPat l) $ fix p + _ -> return p + where fix x = applyFixities fixs x
+ HSE/Annotated/Simplify.hs view
@@ -0,0 +1,522 @@+----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Annotated.Simplify +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- This module contains code for translating from the annotated +-- complex AST in HSE.Annotated.Syntax +-- to the simpler, sparsely annotated AST in HSE.Syntax. +-- +-- A function @sXYZ@ translates an annotated AST node of type @XYZ l@ into +-- a simple AST node of type @XYZ@. I would have prefered to use a MPTC +-- with an fd/type family to get a single exported function name, but +-- I wish to stay Haskell 2010 compliant. Let's hope for Haskell 2011. +-- +----------------------------------------------------------------------------- +module HSE.Annotated.Simplify where + +import HSE.Annotated.Syntax +import qualified HSE.Syntax as S + +import HSE.SrcLoc + +-- | Translate an annotated AST node representing a Haskell module, into +-- a simpler version that retains (almost) only abstract information. +-- In particular, XML and hybrid XML pages enabled by the XmlSyntax extension +-- are translated into standard Haskell modules with a @page@ function. +sModule :: SrcInfo loc => Module loc -> S.Module +sModule md = case md of + Module l mmh oss ids ds -> + let (mn, mwt, mes) = sModuleHead mmh + in S.Module (getPointLoc l) mn (map sModulePragma oss) mwt mes (map sImportDecl ids) (map sDecl ds) + XmlPage l mn oss xn attrs mat es -> + let loc = getPointLoc l + in S.Module loc (sModuleName mn) (map sModulePragma oss) + Nothing + (Just [S.EVar $ S.UnQual $ S.Ident "page"]) + [] + [pageFun loc $ S.XTag loc (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)] + XmlHybrid l mmh oss ids ds xn attrs mat es -> + let loc1 = getPointLoc l + loc2 = getPointLoc (ann xn) + (mn, mwt, mes) = sModuleHead mmh + in S.Module loc1 mn (map sModulePragma oss) mwt mes (map sImportDecl ids) + (map sDecl ds ++ [pageFun loc2 $ S.XTag loc2 (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)]) + where pageFun :: SrcLoc -> S.Exp -> S.Decl + pageFun loc e = S.PatBind loc namePat Nothing rhs (S.BDecls []) + where namePat = S.PVar $ S.Ident "page" + rhs = S.UnGuardedRhs e + + +-- | Translate an annotated AST node representing a Haskell declaration +-- into a simpler version. Note that in the simpler version, all declaration +-- nodes are still annotated by 'SrcLoc's. +sDecl :: SrcInfo loc => Decl loc -> S.Decl +sDecl decl = case decl of + TypeDecl l dh t -> + let (n, tvs) = sDeclHead dh + in S.TypeDecl (getPointLoc l) n tvs (sType t) + TypeFamDecl l dh mk -> + let (n, tvs) = sDeclHead dh + in S.TypeFamDecl (getPointLoc l) n tvs (fmap sKind mk) + DataDecl l dn mctxt dh constrs mder -> + let (n, tvs) = sDeclHead dh + in S.DataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (map sQualConDecl constrs) (maybe [] sDeriving mder) + GDataDecl l dn mctxt dh mk gds mder -> + let (n, tvs) = sDeclHead dh + in S.GDataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder) + DataFamDecl l mctxt dh mk -> + let (n, tvs) = sDeclHead dh + in S.DataFamDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk) + TypeInsDecl l t1 t2 -> S.TypeInsDecl (getPointLoc l) (sType t1) (sType t2) + DataInsDecl l dn t constrs mder -> + S.DataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder) + GDataInsDecl l dn t mk gds mder -> + S.GDataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder) + ClassDecl l mctxt dh fds mcds -> + let (n, tvs) = sDeclHead dh + in S.ClassDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (map sFunDep fds) (maybe [] (map sClassDecl) mcds) + InstDecl l mctxt ih mids -> + let (qn, ts) = sInstHead ih + in S.InstDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts (maybe [] (map sInstDecl) mids) + DerivDecl l mctxt ih -> + let (qn, ts) = sInstHead ih + in S.DerivDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts + InfixDecl l ass prec ops -> S.InfixDecl (getPointLoc l) (sAssoc ass) (maybe 9 id prec) (map sOp ops) + DefaultDecl l ts -> S.DefaultDecl (getPointLoc l) (map sType ts) + SpliceDecl l sp -> S.SpliceDecl (getPointLoc l) (sExp sp) + TypeSig l ns t -> S.TypeSig (getPointLoc l) (map sName ns) (sType t) + FunBind _ ms -> S.FunBind (map sMatch ms) + PatBind l p mt rhs mbs -> + S.PatBind (getPointLoc l) (sPat p) (fmap sType mt) (sRhs rhs) (maybe (S.BDecls []) sBinds mbs) + ForImp l cc msaf mstr n t -> + S.ForImp (getPointLoc l) (sCallConv cc) (maybe (S.PlaySafe False) sSafety msaf) (maybe "" id mstr) (sName n) (sType t) + ForExp l cc mstr n t -> + S.ForExp (getPointLoc l) (sCallConv cc) (maybe "" id mstr) (sName n) (sType t) + RulePragmaDecl l rs -> S.RulePragmaDecl (getPointLoc l) (map sRule rs) + DeprPragmaDecl l nsstrs -> S.DeprPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs) + WarnPragmaDecl l nsstrs -> S.WarnPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs) + InlineSig l b mact qn -> S.InlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn) + InlineConlikeSig l mact qn -> S.InlineConlikeSig (getPointLoc l) (maybe S.AlwaysActive sActivation mact) (sQName qn) + SpecSig l qn ts -> S.SpecSig (getPointLoc l) (sQName qn) (map sType ts) + SpecInlineSig l b mact qn ts -> + S.SpecInlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn) (map sType ts) + InstSig l mctxt ih -> + let (qn, ts) = sInstHead ih + in S.InstSig (getPointLoc l) (maybe [] sContext mctxt) qn ts + AnnPragma l ann -> + S.AnnPragma (getPointLoc l) (sAnnotation ann) + +sAnnotation :: SrcInfo loc => Annotation loc -> S.Annotation +sAnnotation ann = case ann of + Ann _ n e -> S.Ann (sName n) (sExp e) + TypeAnn _ n e -> S.TypeAnn (sName n) (sExp e) + ModuleAnn _ e -> S.ModuleAnn (sExp e) + +sModuleName :: ModuleName l -> S.ModuleName +sModuleName (ModuleName _ str) = S.ModuleName str + +sSpecialCon :: SpecialCon l -> S.SpecialCon +sSpecialCon sc = case sc of + UnitCon _ -> S.UnitCon + ListCon _ -> S.ListCon + FunCon _ -> S.FunCon + TupleCon _ b k -> S.TupleCon b k + Cons _ -> S.Cons + UnboxedSingleCon _ -> S.UnboxedSingleCon + +sQName :: QName l -> S.QName +sQName qn = case qn of + Qual _ mn n -> S.Qual (sModuleName mn) (sName n) + UnQual _ n -> S.UnQual (sName n) + Special _ sc -> S.Special (sSpecialCon sc) + +sName :: Name l -> S.Name +sName (Ident _ str) = S.Ident str +sName (Symbol _ str) = S.Symbol str + +sIPName :: IPName l -> S.IPName +sIPName (IPDup _ str) = S.IPDup str +sIPName (IPLin _ str) = S.IPLin str + +sQOp :: QOp l -> S.QOp +sQOp (QVarOp _ qn) = S.QVarOp (sQName qn) +sQOp (QConOp _ qn) = S.QConOp (sQName qn) + +sOp :: Op l -> S.Op +sOp (VarOp _ n) = S.VarOp (sName n) +sOp (ConOp _ n) = S.ConOp (sName n) + +sCName :: CName l -> S.CName +sCName (VarName _ n) = S.VarName (sName n) +sCName (ConName _ n) = S.ConName (sName n) + +sModuleHead :: Maybe (ModuleHead l) -> (S.ModuleName, Maybe (S.WarningText), Maybe [S.ExportSpec]) +sModuleHead mmh = case mmh of + Nothing -> (S.main_mod, Nothing, Just [S.EVar (S.UnQual S.main_name)]) + Just (ModuleHead _ mn mwt mel) -> (sModuleName mn, fmap sWarningText mwt, fmap sExportSpecList mel) + +sExportSpecList :: ExportSpecList l -> [S.ExportSpec] +sExportSpecList (ExportSpecList _ ess) = map sExportSpec ess + +sExportSpec :: ExportSpec l -> S.ExportSpec +sExportSpec es = case es of + EVar _ qn -> S.EVar (sQName qn) + EAbs _ qn -> S.EAbs (sQName qn) + EThingAll _ qn -> S.EThingAll (sQName qn) + EThingWith _ qn cns -> S.EThingWith (sQName qn) (map sCName cns) + EModuleContents _ mn -> S.EModuleContents (sModuleName mn) + +sImportDecl :: SrcInfo loc => ImportDecl loc -> S.ImportDecl +sImportDecl (ImportDecl l mn qu src mpkg as misl) = + S.ImportDecl (getPointLoc l) (sModuleName mn) qu src mpkg (fmap sModuleName as) (fmap sImportSpecList misl) + +sImportSpecList :: ImportSpecList l -> (Bool, [S.ImportSpec]) +sImportSpecList (ImportSpecList _ b iss) = (b, map sImportSpec iss) + +sImportSpec :: ImportSpec l -> S.ImportSpec +sImportSpec is = case is of + IVar _ n -> S.IVar (sName n) + IAbs _ n -> S.IAbs (sName n) + IThingAll _ n -> S.IThingAll (sName n) + IThingWith _ n cns -> S.IThingWith (sName n) (map sCName cns) + +sAssoc :: Assoc l -> S.Assoc +sAssoc a = case a of + AssocNone _ -> S.AssocNone + AssocLeft _ -> S.AssocLeft + AssocRight _ -> S.AssocRight + +sDeclHead :: DeclHead l -> (S.Name, [S.TyVarBind]) +sDeclHead dh = case dh of + DHead _ n tvs -> (sName n, map sTyVarBind tvs) + DHInfix _ tva n tvb -> (sName n, map sTyVarBind [tva,tvb]) + DHParen _ dh -> sDeclHead dh + +sInstHead :: InstHead l -> (S.QName, [S.Type]) +sInstHead ih = case ih of + IHead _ qn ts -> (sQName qn, map sType ts) + IHInfix _ ta qn tb -> (sQName qn, map sType [ta,tb]) + IHParen _ ih -> sInstHead ih + +sDataOrNew :: DataOrNew l -> S.DataOrNew +sDataOrNew (DataType _) = S.DataType +sDataOrNew (NewType _) = S.NewType + +sDeriving :: (Deriving l) -> [(S.QName, [S.Type])] +sDeriving (Deriving _ ihs) = map sInstHead ihs + +sBinds :: SrcInfo loc => Binds loc -> S.Binds +sBinds bs = case bs of + BDecls _ decls -> S.BDecls (map sDecl decls) + IPBinds _ ipbds -> S.IPBinds (map sIPBind ipbds) + +sIPBind :: SrcInfo loc => IPBind loc -> S.IPBind +sIPBind (IPBind l ipn e) = S.IPBind (getPointLoc l) (sIPName ipn) (sExp e) + +sMatch :: SrcInfo loc => Match loc -> S.Match +sMatch (Match l n ps rhs mwhere) = + S.Match (getPointLoc l) (sName n) (map sPat ps) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere) +sMatch (InfixMatch l pa n pbs rhs mwhere) = + S.Match (getPointLoc l) (sName n) (map sPat (pa:pbs)) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere) + +sQualConDecl :: SrcInfo loc => QualConDecl loc -> S.QualConDecl +sQualConDecl (QualConDecl l mtvs mctxt cd) = + S.QualConDecl (getPointLoc l) (maybe [] (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sConDecl cd) + +sConDecl :: ConDecl l -> S.ConDecl +sConDecl cd = case cd of + ConDecl _ n bts -> S.ConDecl (sName n) (map sBangType bts) + InfixConDecl _ bta n btb -> S.InfixConDecl (sBangType bta) (sName n) (sBangType btb) + RecDecl _ n fds -> S.RecDecl (sName n) (map sFieldDecl fds) + +sFieldDecl :: FieldDecl l -> ([S.Name], S.BangType) +sFieldDecl (FieldDecl _ ns bt) = (map sName ns, sBangType bt) + +sGadtDecl :: SrcInfo loc => GadtDecl loc -> S.GadtDecl +sGadtDecl (GadtDecl l n t) = S.GadtDecl (getPointLoc l) (sName n) (sType t) + +sClassDecl :: SrcInfo loc => ClassDecl loc -> S.ClassDecl +sClassDecl cd = case cd of + ClsDecl _ d -> S.ClsDecl (sDecl d) + ClsDataFam l mctxt dh mk -> + let (n, tvs) = sDeclHead dh + in S.ClsDataFam (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk) + ClsTyFam l dh mk -> + let (n, tvs) = sDeclHead dh + in S.ClsTyFam (getPointLoc l) n tvs (fmap sKind mk) + ClsTyDef l t1 t2 -> + S.ClsTyDef (getPointLoc l) (sType t1) (sType t2) + +sInstDecl :: SrcInfo loc => InstDecl loc -> S.InstDecl +sInstDecl id = case id of + InsDecl _ d -> S.InsDecl (sDecl d) + InsType l t1 t2 -> S.InsType (getPointLoc l) (sType t1) (sType t2) + InsData l dn t constrs mder -> + S.InsData (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder) + InsGData l dn t mk gds mder -> + S.InsGData (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder) +-- InsInline l b mact qn -> S.InsInline (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn) + +sBangType :: BangType l -> S.BangType +sBangType bt = case bt of + BangedTy _ t -> S.BangedTy (sType t) + UnBangedTy _ t -> S.UnBangedTy (sType t) + UnpackedTy _ t -> S.UnpackedTy (sType t) + +sRhs :: SrcInfo loc => Rhs loc -> S.Rhs +sRhs (UnGuardedRhs _ e) = S.UnGuardedRhs (sExp e) +sRhs (GuardedRhss _ grhss) = S.GuardedRhss (map sGuardedRhs grhss) + +sGuardedRhs :: SrcInfo loc => GuardedRhs loc -> S.GuardedRhs +sGuardedRhs (GuardedRhs l ss e) = S.GuardedRhs (getPointLoc l) (map sStmt ss) (sExp e) + +sType :: Type l -> S.Type +sType t = case t of + TyForall _ mtvs mctxt t -> S.TyForall (fmap (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sType t) + TyFun _ t1 t2 -> S.TyFun (sType t1) (sType t2) + TyTuple _ bx ts -> S.TyTuple bx (map sType ts) + TyList _ t -> S.TyList (sType t) + TyApp _ t1 t2 -> S.TyApp (sType t1) (sType t2) + TyVar _ n -> S.TyVar (sName n) + TyCon _ qn -> S.TyCon (sQName qn) + TyParen _ t -> S.TyParen (sType t) + TyInfix _ ta qn tb -> S.TyInfix (sType ta) (sQName qn) (sType tb) + TyKind _ t k -> S.TyKind (sType t) (sKind k) + +sTyVarBind :: TyVarBind l -> S.TyVarBind +sTyVarBind (KindedVar _ n k) = S.KindedVar (sName n) (sKind k) +sTyVarBind (UnkindedVar _ n) = S.UnkindedVar (sName n) + +sKind :: Kind l -> S.Kind +sKind k = case k of + KindStar _ -> S.KindStar + KindBang _ -> S.KindBang + KindFn _ k1 k2 -> S.KindFn (sKind k1) (sKind k2) + KindParen _ k -> S.KindParen (sKind k) + KindVar _ n -> S.KindVar (sName n) + +sFunDep :: FunDep l -> S.FunDep +sFunDep (FunDep _ as bs) = S.FunDep (map sName as) (map sName bs) + +sContext :: Context l -> S.Context +sContext ctxt = case ctxt of + CxSingle _ asst -> [sAsst asst] + CxTuple _ assts -> map sAsst assts + CxParen _ ct -> sContext ct + CxEmpty _ -> [] + +sAsst :: Asst l -> S.Asst +sAsst asst = case asst of + ClassA _ qn ts -> S.ClassA (sQName qn) (map sType ts) + InfixA _ ta qn tb -> S.InfixA (sType ta) (sQName qn) (sType tb) + IParam _ ipn t -> S.IParam (sIPName ipn) (sType t) + EqualP _ t1 t2 -> S.EqualP (sType t1) (sType t2) + +sLiteral :: Literal l -> S.Literal +sLiteral lit = case lit of + Char _ c _ -> S.Char c + String _ s _ -> S.String s + Int _ i _ -> S.Int i + Frac _ r _ -> S.Frac r + PrimInt _ i _ -> S.PrimInt i + PrimWord _ i _ -> S.PrimWord i + PrimFloat _ r _ -> S.PrimFloat r + PrimDouble _ r _ -> S.PrimDouble r + PrimChar _ c _ -> S.PrimChar c + PrimString _ s _ -> S.PrimString s + +sExp :: SrcInfo loc => Exp loc -> S.Exp +sExp e = case e of + Var _ qn -> S.Var (sQName qn) + FreeSectSlot _ -> S.FreeSectSlot + IPVar _ ipn -> S.IPVar (sIPName ipn) + Con _ qn -> S.Con (sQName qn) + Lit _ lit -> S.Lit (sLiteral lit) + InfixApp _ e1 op e2 -> S.InfixApp (sExp e1) (sQOp op) (sExp e2) + App _ e1 e2 -> S.App (sExp e1) (sExp e2) + NegApp _ e -> S.NegApp (sExp e) + Lambda l ps e -> S.Lambda (getPointLoc l) (map sPat ps) (sExp e) + Let _ bs e -> S.Let (sBinds bs) (sExp e) + If _ e1 e2 e3 -> S.If (sExp e1) (sExp e2) (sExp e3) + Case _ e alts -> S.Case (sExp e) (map sAlt alts) + Do _ ss -> S.Do (map sStmt ss) + MDo _ ss -> S.MDo (map sStmt ss) + Tuple _ es -> S.Tuple (map sExp es) + TupleSection _ mes -> S.TupleSection (map (fmap sExp) mes) + List _ es -> S.List (map sExp es) + FSContext _ e -> S.FSContext (sExp e) + Paren _ e -> S.Paren (sExp e) + LeftSection _ e op -> S.LeftSection (sExp e) (sQOp op) + RightSection _ op e -> S.RightSection (sQOp op) (sExp e) + RecConstr _ qn fups -> S.RecConstr (sQName qn) (map sFieldUpdate fups) + RecUpdate _ e fups -> S.RecUpdate (sExp e) (map sFieldUpdate fups) + EnumFrom _ e -> S.EnumFrom (sExp e) + EnumFromTo _ e1 e2 -> S.EnumFromTo (sExp e1) (sExp e2) + EnumFromThen _ e1 e2 -> S.EnumFromThen (sExp e1) (sExp e2) + EnumFromThenTo _ e1 e2 e3 -> S.EnumFromThenTo (sExp e1) (sExp e2) (sExp e3) + ListComp _ e qss -> S.ListComp (sExp e) (map sQualStmt qss) + ParComp _ e qsss -> S.ParComp (sExp e) (map (map sQualStmt) qsss) + ExpTypeSig l e t -> S.ExpTypeSig (getPointLoc l) (sExp e) (sType t) + VarQuote _ qn -> S.VarQuote (sQName qn) + TypQuote _ qn -> S.TypQuote (sQName qn) + BracketExp _ br -> S.BracketExp (sBracket br) + SpliceExp _ sp -> S.SpliceExp (sSplice sp) + QuasiQuote _ nm qt -> S.QuasiQuote nm qt + XTag l xn attrs mat es -> S.XTag (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es) + XETag l xn attrs mat -> S.XETag (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat) + XPcdata _ str -> S.XPcdata str + XExpTag _ e -> S.XExpTag (sExp e) + XChildTag l es -> S.XChildTag (getPointLoc l) (map sExp es) + CorePragma _ str e -> S.CorePragma str (sExp e) + SCCPragma _ str e -> S.SCCPragma str (sExp e) + GenPragma _ str i12 i34 e -> S.GenPragma str i12 i34 (sExp e) + Proc l p e -> S.Proc (getPointLoc l) (sPat p) (sExp e) + LeftArrApp _ e1 e2 -> S.LeftArrApp (sExp e1) (sExp e2) + RightArrApp _ e1 e2 -> S.RightArrApp (sExp e1) (sExp e2) + LeftArrHighApp _ e1 e2 -> S.LeftArrHighApp (sExp e1) (sExp e2) + RightArrHighApp _ e1 e2 -> S.RightArrHighApp (sExp e1) (sExp e2) + + +sXName :: XName l -> S.XName +sXName (XName _ str) = S.XName str +sXName (XDomName _ dom str) = S.XDomName dom str + +sXAttr :: SrcInfo loc => XAttr loc -> S.XAttr +sXAttr (XAttr _ xn e) = S.XAttr (sXName xn) (sExp e) + +sBracket:: SrcInfo loc => Bracket loc -> S.Bracket +sBracket br = case br of + ExpBracket _ e -> S.ExpBracket (sExp e) + PatBracket _ p -> S.PatBracket (sPat p) + TypeBracket _ t -> S.TypeBracket (sType t) + DeclBracket _ ds -> S.DeclBracket (map sDecl ds) + +sSplice :: SrcInfo loc => Splice loc -> S.Splice +sSplice (IdSplice _ str) = S.IdSplice str +sSplice (ParenSplice _ e) = S.ParenSplice (sExp e) + +sSafety :: Safety l -> S.Safety +sSafety (PlayRisky _) = S.PlayRisky +sSafety (PlaySafe _ b) = S.PlaySafe b + +sCallConv :: CallConv l -> S.CallConv +sCallConv (StdCall _) = S.StdCall +sCallConv (CCall _) = S.CCall + +sModulePragma :: SrcInfo loc => ModulePragma loc -> S.ModulePragma +sModulePragma pr = case pr of + LanguagePragma l ns -> S.LanguagePragma (getPointLoc l) (map sName ns) + OptionsPragma l mt str -> S.OptionsPragma (getPointLoc l) mt str + AnnModulePragma l ann -> S.AnnModulePragma (getPointLoc l) (sAnnotation ann) + +sActivation :: Activation l -> S.Activation +sActivation act = case act of + ActiveFrom _ k -> S.ActiveFrom k + ActiveUntil _ k -> S.ActiveUntil k + +sRule :: SrcInfo loc => Rule loc -> S.Rule +sRule (Rule _ str mact mrvs e1 e2) = + S.Rule str (maybe S.AlwaysActive sActivation mact) (fmap (map sRuleVar) mrvs) (sExp e1) (sExp e2) + +sRuleVar :: RuleVar l -> S.RuleVar +sRuleVar (RuleVar _ n) = S.RuleVar (sName n) +sRuleVar (TypedRuleVar _ n t) = S.TypedRuleVar (sName n) (sType t) + +sWarningText :: WarningText l -> S.WarningText +sWarningText (DeprText _ str) = S.DeprText str +sWarningText (WarnText _ str) = S.WarnText str + +sPat :: SrcInfo loc => Pat loc -> S.Pat +sPat pat = case pat of + PVar _ n -> S.PVar (sName n) + PLit _ lit -> S.PLit (sLiteral lit) + PNeg _ p -> S.PNeg (sPat p) + PNPlusK _ n k -> S.PNPlusK (sName n) k + PInfixApp _ pa qn pb -> S.PInfixApp (sPat pa) (sQName qn) (sPat pb) + PApp _ qn ps -> S.PApp (sQName qn) (map sPat ps) + PTuple _ ps -> S.PTuple (map sPat ps) + PList _ ps -> S.PList (map sPat ps) + PParen _ p -> S.PParen (sPat p) + PRec _ qn pfs -> S.PRec (sQName qn) (map sPatField pfs) + PAsPat _ n p -> S.PAsPat (sName n) (sPat p) + PWildCard _ -> S.PWildCard + PIrrPat _ p -> S.PIrrPat (sPat p) + PatTypeSig l p t -> S.PatTypeSig (getPointLoc l) (sPat p) (sType t) + PViewPat _ e p -> S.PViewPat (sExp e) (sPat p) + PRPat _ rps -> S.PRPat (map sRPat rps) + PXTag l xn attrs mat ps -> S.PXTag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat) (map sPat ps) + PXETag l xn attrs mat -> S.PXETag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat) + PXPcdata _ str -> S.PXPcdata str + PXPatTag _ p -> S.PXPatTag (sPat p) + PXRPats _ rps -> S.PXRPats (map sRPat rps) + PExplTypeArg _ qn t -> S.PExplTypeArg (sQName qn) (sType t) + PQuasiQuote _ nm qt -> S.PQuasiQuote nm qt + PBangPat _ p -> S.PBangPat (sPat p) + +sPXAttr :: SrcInfo loc => PXAttr loc -> S.PXAttr +sPXAttr (PXAttr _ xn p) = S.PXAttr (sXName xn) (sPat p) + +sRPatOp :: RPatOp l -> S.RPatOp +sRPatOp rpop = case rpop of + RPStar _ -> S.RPStar + RPStarG _ -> S.RPStarG + RPPlus _ -> S.RPPlus + RPPlusG _ -> S.RPPlusG + RPOpt _ -> S.RPOpt + RPOptG _ -> S.RPOptG + +sRPat :: SrcInfo loc => RPat loc -> S.RPat +sRPat rp = case rp of + RPOp _ rp rop -> S.RPOp (sRPat rp) (sRPatOp rop) + RPEither _ rp1 rp2 -> S.RPEither (sRPat rp1) (sRPat rp2) + RPSeq _ rps -> S.RPSeq (map sRPat rps) + RPGuard _ p ss -> S.RPGuard (sPat p) (map sStmt ss) + RPCAs _ n rp -> S.RPCAs (sName n) (sRPat rp) + RPAs _ n rp -> S.RPAs (sName n) (sRPat rp) + RPParen _ rp -> S.RPParen (sRPat rp) + RPPat _ p -> S.RPPat (sPat p) + +sPatField :: SrcInfo loc => PatField loc -> S.PatField +sPatField pf = case pf of + PFieldPat _ qn p -> S.PFieldPat (sQName qn) (sPat p) + PFieldPun _ n -> S.PFieldPun (sName n) + PFieldWildcard _ -> S.PFieldWildcard + +sStmt :: SrcInfo loc => Stmt loc -> S.Stmt +sStmt stmt = case stmt of + Generator l p e -> S.Generator (getPointLoc l) (sPat p) (sExp e) + Qualifier _ e -> S.Qualifier (sExp e) + LetStmt _ bs -> S.LetStmt (sBinds bs) + RecStmt _ ss -> S.RecStmt (map sStmt ss) + +sQualStmt :: SrcInfo loc => QualStmt loc -> S.QualStmt +sQualStmt qs = case qs of + QualStmt _ stmt -> S.QualStmt (sStmt stmt) + ThenTrans _ e -> S.ThenTrans (sExp e) + ThenBy _ e1 e2 -> S.ThenBy (sExp e1) (sExp e2) + GroupBy _ e -> S.GroupBy (sExp e) + GroupUsing _ e -> S.GroupUsing (sExp e) + GroupByUsing _ e1 e2 -> S.GroupByUsing (sExp e1) (sExp e2) + +sFieldUpdate :: SrcInfo loc => FieldUpdate loc -> S.FieldUpdate +sFieldUpdate fu = case fu of + FieldUpdate _ qn e -> S.FieldUpdate (sQName qn) (sExp e) + FieldPun _ n -> S.FieldPun (sName n) + FieldWildcard _ -> S.FieldWildcard + +sAlt :: SrcInfo loc => Alt loc -> S.Alt +sAlt (Alt l p galts mbs) = S.Alt (getPointLoc l) (sPat p) (sGuardedAlts galts) (maybe (S.BDecls []) sBinds mbs) + +sGuardedAlts :: SrcInfo loc => GuardedAlts loc -> S.GuardedAlts +sGuardedAlts galts = case galts of + UnGuardedAlt _ e -> S.UnGuardedAlt (sExp e) + GuardedAlts _ gs -> S.GuardedAlts (map sGuardedAlt gs) + +sGuardedAlt :: SrcInfo loc => GuardedAlt loc -> S.GuardedAlt +sGuardedAlt (GuardedAlt l ss e) = S.GuardedAlt (getPointLoc l) (map sStmt ss) (sExp e)
+ HSE/Annotated/Syntax.hs view
@@ -0,0 +1,2231 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Annotated.Syntax+-- Copyright : (c) Niklas Broberg 2004-2009,+-- (c) The GHC Team, 1997-2000+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- A suite of datatypes describing the (semi-concrete) abstract syntax of Haskell 98+-- <http://www.haskell.org/onlinereport/> plus registered extensions, including:+--+-- * multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)+--+-- * parameters of type class assertions are unrestricted (FlexibleContexts)+--+-- * 'forall' types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)+--+-- * pattern guards (PatternGuards)+--+-- * implicit parameters (ImplicitParameters)+--+-- * generalised algebraic data types (GADTs)+--+-- * template haskell (TemplateHaskell)+--+-- * empty data type declarations (EmptyDataDecls)+--+-- * unboxed tuples (UnboxedTuples)+--+-- * regular patterns (RegularPatterns)+--+-- * HSP-style XML expressions and patterns (XmlSyntax)+--+-- All nodes in the syntax tree are annotated with something of a user-definable data type.+-- When parsing, this annotation will contain information about the source location that the+-- particular node comes from.+--+-----------------------------------------------------------------------------++module HSE.Annotated.Syntax (+ -- * Modules+ Module(..), ModuleHead(..), WarningText(..), ExportSpecList(..), ExportSpec(..),+ ImportDecl(..), ImportSpecList(..), ImportSpec(..), Assoc(..),+ -- * Declarations+ Decl(..), DeclHead(..), InstHead(..), Binds(..), IPBind(..),+ -- ** Type classes and instances+ ClassDecl(..), InstDecl(..), Deriving(..),+ -- ** Data type declarations+ DataOrNew(..), ConDecl(..), FieldDecl(..), QualConDecl(..), GadtDecl(..), BangType(..),+ -- ** Function bindings+ Match(..), Rhs(..), GuardedRhs(..),+ -- * Class Assertions and Contexts+ Context(..), FunDep(..), Asst(..),+ -- * Types+ Type(..), Boxed(..), Kind(..), TyVarBind(..),+ -- * Expressions+ Exp(..), Stmt(..), QualStmt(..), FieldUpdate(..),+ Alt(..), GuardedAlts(..), GuardedAlt(..), XAttr(..),+ -- * Patterns+ Pat(..), PatField(..), PXAttr(..), RPat(..), RPatOp(..),+ -- * Literals+ Literal(..),+ -- * Variables, Constructors and Operators+ ModuleName(..), QName(..), Name(..), QOp(..), Op(..),+ SpecialCon(..), CName(..), IPName(..), XName(..),++ -- * Template Haskell+ Bracket(..), Splice(..),++ -- * FFI+ Safety(..), CallConv(..),++ -- * Pragmas+ ModulePragma(..), Tool(..),+ Rule(..), RuleVar(..), Activation(..),+ Annotation(..),++ -- * Builtin names++ -- ** Modules+ prelude_mod, main_mod,+ -- ** Main function of a program+ main_name,+ -- ** Constructors+ unit_con_name, tuple_con_name, list_cons_name, unboxed_singleton_con_name,+ unit_con, tuple_con, unboxed_singleton_con,+ -- ** Special identifiers+ as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,+ export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name,+ -- ** Type constructors+ unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name, unboxed_singleton_tycon_name,+ unit_tycon, fun_tycon, list_tycon, tuple_tycon, unboxed_singleton_tycon,++ -- * Source coordinates+ -- SrcLoc(..),++ -- * Annotated trees+ Annotated(..), (=~=),+ ) where+++#ifdef __GLASGOW_HASKELL__+#ifdef BASE4+import Data.Data+#else+import Data.Generics (Data(..),Typeable(..))+#endif+#endif+++-- | The name of a Haskell module.+data ModuleName l = ModuleName l String+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Constructors with special syntax.+-- These names are never qualified, and always refer to builtin type or+-- data constructors.+data SpecialCon l+ = UnitCon l -- ^ unit type and data constructor @()@+ | ListCon l -- ^ list type constructor @[]@+ | FunCon l -- ^ function type constructor @->@+ | TupleCon l Boxed Int -- ^ /n/-ary tuple type and data+ -- constructors @(,)@ etc, possibly boxed @(\#,\#)@+ | Cons l -- ^ list data constructor @(:)@+ | UnboxedSingleCon l -- ^ unboxed singleton tuple constructor @(\# \#)@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | This type is used to represent qualified variables, and also+-- qualified constructors.+data QName l+ = Qual l (ModuleName l) (Name l) -- ^ name qualified with a module name+ | UnQual l (Name l) -- ^ unqualified local name+ | Special l (SpecialCon l) -- ^ built-in constructor with special syntax+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | This type is used to represent variables, and also constructors.+data Name l+ = Ident l String -- ^ /varid/ or /conid/.+ | Symbol l String -- ^ /varsym/ or /consym/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An implicit parameter name.+data IPName l+ = IPDup l String -- ^ ?/ident/, non-linear implicit parameter+ | IPLin l String -- ^ %/ident/, linear implicit parameter+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Possibly qualified infix operators (/qop/), appearing in expressions.+data QOp l+ = QVarOp l (QName l) -- ^ variable operator (/qvarop/)+ | QConOp l (QName l) -- ^ constructor operator (/qconop/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Operators appearing in @infix@ declarations are never qualified.+data Op l+ = VarOp l (Name l) -- ^ variable operator (/varop/)+ | ConOp l (Name l) -- ^ constructor operator (/conop/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A name (/cname/) of a component of a class or data type in an @import@+-- or export specification.+data CName l+ = VarName l (Name l) -- ^ name of a method or field+ | ConName l (Name l) -- ^ name of a data constructor+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A complete Haskell source module.+data Module l+ = Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]+ -- ^ an ordinary Haskell module+ | XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]+ -- ^ a module consisting of a single XML document. The ModuleName never appears in the source+ -- but is needed for semantic purposes, it will be the same as the file name.+ | XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]+ (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]+ -- ^ a hybrid module combining an XML document with an ordinary module+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The head of a module, including the name and export specification.+data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An explicit export specification.+data ExportSpecList l+ = ExportSpecList l [ExportSpec l]+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An item in a module's export specification.+data ExportSpec l+ = EVar l (QName l) -- ^ variable+ | EAbs l (QName l) -- ^ @T@:+ -- a class or datatype exported abstractly,+ -- or a type synonym.+ | EThingAll l (QName l) -- ^ @T(..)@:+ -- a class exported with all of its methods, or+ -- a datatype exported with all of its constructors.+ | EThingWith l (QName l) [CName l] -- ^ @T(C_1,...,C_n)@:+ -- a class exported with some of its methods, or+ -- a datatype exported with some of its constructors.+ | EModuleContents l (ModuleName l) -- ^ @module M@:+ -- re-export a module.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An import declaration.+data ImportDecl l = ImportDecl+ { importAnn :: l -- ^ annotation, used by parser for position of the @import@ keyword.+ , importModule :: (ModuleName l) -- ^ name of the module imported.+ , importQualified :: Bool -- ^ imported @qualified@?+ , importSrc :: Bool -- ^ imported with @{-\# SOURCE \#-}@?+ , importPkg :: Maybe String -- ^ imported with explicit package name+ , importAs :: Maybe (ModuleName l) -- ^ optional alias name in an @as@ clause.+ , importSpecs :: Maybe (ImportSpecList l)+ -- ^ optional list of import specifications.+ }+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An explicit import specification list.+data ImportSpecList l+ = ImportSpecList l Bool [ImportSpec l]+ -- A list of import specifications.+ -- The 'Bool' is 'True' if the names are excluded+ -- by @hiding@.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An import specification, representing a single explicit item imported+-- (or hidden) from a module.+data ImportSpec l+ = IVar l (Name l) -- ^ variable+ | IAbs l (Name l) -- ^ @T@:+ -- the name of a class, datatype or type synonym.+ | IThingAll l (Name l) -- ^ @T(..)@:+ -- a class imported with all of its methods, or+ -- a datatype imported with all of its constructors.+ | IThingWith l (Name l) [CName l] -- ^ @T(C_1,...,C_n)@:+ -- a class imported with some of its methods, or+ -- a datatype imported with some of its constructors.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Associativity of an operator.+data Assoc l+ = AssocNone l -- ^ non-associative operator (declared with @infix@)+ | AssocLeft l -- ^ left-associative operator (declared with @infixl@).+ | AssocRight l -- ^ right-associative operator (declared with @infixr@)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A top-level declaration.+data Decl l+ = TypeDecl l (DeclHead l) (Type l)+ -- ^ A type declaration+ | TypeFamDecl l (DeclHead l) (Maybe (Kind l))+ -- ^ A type family declaration+ | DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] (Maybe (Deriving l))+ -- ^ A data OR newtype declaration+ | GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))+ -- ^ A data OR newtype declaration, GADT style+ | DataFamDecl l {-data-} (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))+ -- ^ A data family declaration+ | TypeInsDecl l (Type l) (Type l)+ -- ^ A type family instance declaration+ | DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))+ -- ^ A data family instance declaration+ | GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))+ -- ^ A data family instance declaration, GADT style+ | ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])+ -- ^ A declaration of a type class+ | InstDecl l (Maybe (Context l)) (InstHead l) (Maybe [InstDecl l])+ -- ^ An declaration of a type class instance+ | DerivDecl l (Maybe (Context l)) (InstHead l)+ -- ^ A standalone deriving declaration+ | InfixDecl l (Assoc l) (Maybe Int) [Op l]+ -- ^ A declaration of operator fixity+ | DefaultDecl l [Type l]+ -- ^ A declaration of default types+ | SpliceDecl l (Exp l)+ -- ^ A Template Haskell splicing declaration+ | TypeSig l [Name l] (Type l)+ -- ^ A type signature declaration+ | FunBind l [Match l]+ -- ^ A set of function binding clauses+ | PatBind l (Pat l) (Maybe (Type l)) (Rhs l) {-where-} (Maybe (Binds l))+ -- ^ A pattern binding+ | ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)+ -- ^ A foreign import declaration+ | ForExp l (CallConv l) (Maybe String) (Name l) (Type l)+ -- ^ A foreign export declaration+ | RulePragmaDecl l [Rule l]+ -- ^ A RULES pragma+ | DeprPragmaDecl l [([Name l], String)]+ -- ^ A DEPRECATED pragma+ | WarnPragmaDecl l [([Name l], String)]+ -- ^ A WARNING pragma+ | InlineSig l Bool (Maybe (Activation l)) (QName l)+ -- ^ An INLINE pragma+ | InlineConlikeSig l (Maybe (Activation l)) (QName l)+ -- ^ An INLINE CONLIKE pragma+ | SpecSig l (QName l) [Type l]+ -- ^ A SPECIALISE pragma+ | SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]+ -- ^ A SPECIALISE INLINE pragma+ | InstSig l (Maybe (Context l)) (InstHead l)+ -- ^ A SPECIALISE instance pragma+ | AnnPragma l (Annotation l)+ -- ^ An ANN pragma+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An annotation through an ANN pragma.+data Annotation l+ = Ann l (Name l) (Exp l)+ -- ^ An annotation for a declared name.+ | TypeAnn l (Name l) (Exp l)+ -- ^ An annotation for a declared type.+ | ModuleAnn l (Exp l)+ -- ^ An annotation for the defining module.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A flag stating whether a declaration is a data or newtype declaration.+data DataOrNew l = DataType l | NewType l+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The head of a type or class declaration.+data DeclHead l+ = DHead l (Name l) [TyVarBind l]+ | DHInfix l (TyVarBind l) (Name l) (TyVarBind l)+ | DHParen l (DeclHead l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The head of an instance declaration.+data InstHead l+ = IHead l (QName l) [Type l]+ | IHInfix l (Type l) (QName l) (Type l)+ | IHParen l (InstHead l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A deriving clause following a data type declaration.+data Deriving l = Deriving l [InstHead l]+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A binding group inside a @let@ or @where@ clause.+data Binds l+ = BDecls l [Decl l] -- ^ An ordinary binding group+ | IPBinds l [IPBind l] -- ^ A binding group for implicit parameters+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A binding of an implicit parameter.+data IPBind l = IPBind l (IPName l) (Exp l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Clauses of a function binding.+data Match l+ = Match l (Name l) [Pat l] (Rhs l) {-where-} (Maybe (Binds l))+ -- ^ A clause defined with prefix notation, i.e. the function name + -- followed by its argument patterns, the right-hand side and an+ -- optional where clause.+ | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) {-where-} (Maybe (Binds l))+ -- ^ A clause defined with infix notation, i.e. first its first argument+ -- pattern, then the function name, then its following argument(s),+ -- the right-hand side and an optional where clause.+ -- Note that there can be more than two arguments to a function declared+ -- infix, hence the list of pattern arguments.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A single constructor declaration within a data type declaration,+-- which may have an existential quantification binding.+data QualConDecl l+ = QualConDecl l+ {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))+ {- => -} (ConDecl l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declaration of an ordinary data constructor.+data ConDecl l+ = ConDecl l (Name l) [BangType l]+ -- ^ ordinary data constructor+ | InfixConDecl l (BangType l) (Name l) (BangType l)+ -- ^ infix data constructor+ | RecDecl l (Name l) [FieldDecl l]+ -- ^ record constructor+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declaration of a (list of) named field(s).+data FieldDecl l = FieldDecl l [Name l] (BangType l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A single constructor declaration in a GADT data type declaration.+data GadtDecl l+ = GadtDecl l (Name l) (Type l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declarations inside a class declaration.+data ClassDecl l+ = ClsDecl l (Decl l)+ -- ^ ordinary declaration+ | ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))+ -- ^ declaration of an associated data type+ | ClsTyFam l (DeclHead l) (Maybe (Kind l))+ -- ^ declaration of an associated type synonym+ | ClsTyDef l (Type l) (Type l)+ -- ^ default choice for an associated type synonym+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declarations inside an instance declaration.+data InstDecl l+ = InsDecl l (Decl l)+ -- ^ ordinary declaration+ | InsType l (Type l) (Type l)+ -- ^ an associated type definition+ | InsData l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))+ -- ^ an associated data type implementation+ | InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))+ -- ^ an associated data type implemented using GADT style+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The type of a constructor argument or field, optionally including+-- a strictness annotation.+data BangType l+ = BangedTy l (Type l) -- ^ strict component, marked with \"@!@\"+ | UnBangedTy l (Type l) -- ^ non-strict component+ | UnpackedTy l (Type l) -- ^ unboxed component, marked with an UNPACK pragma+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The right hand side of a function or pattern binding.+data Rhs l+ = UnGuardedRhs l (Exp l) -- ^ unguarded right hand side (/exp/)+ | GuardedRhss l [GuardedRhs l]+ -- ^ guarded right hand side (/gdrhs/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A guarded right hand side @|@ /stmts/ @=@ /exp/.+-- The guard is a series of statements when using pattern guards,+-- otherwise it will be a single qualifier expression.+data GuardedRhs l+ = GuardedRhs l [Stmt l] (Exp l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A type qualified with a context.+-- An unqualified type has an empty context.+data Type l+ = TyForall l+ (Maybe [TyVarBind l])+ (Maybe (Context l))+ (Type l) -- ^ qualified type+ | TyFun l (Type l) (Type l) -- ^ function type+ | TyTuple l Boxed [Type l] -- ^ tuple type, possibly boxed+ | TyList l (Type l) -- ^ list syntax, e.g. [a], as opposed to [] a+ | TyApp l (Type l) (Type l) -- ^ application of a type constructor+ | TyVar l (Name l) -- ^ type variable+ | TyCon l (QName l) -- ^ named type or type constructor+ | TyParen l (Type l) -- ^ type surrounded by parentheses+ | TyInfix l (Type l) (QName l) (Type l) -- ^ infix type constructor+ | TyKind l (Type l) (Kind l) -- ^ type with explicit kind signature+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Flag denoting whether a tuple is boxed or unboxed.+data Boxed = Boxed | Unboxed+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A type variable declaration, optionally with an explicit kind annotation.+data TyVarBind l+ = KindedVar l (Name l) (Kind l) -- ^ variable binding with kind annotation+ | UnkindedVar l (Name l) -- ^ ordinary variable binding+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An explicit kind annotation.+data Kind l+ = KindStar l -- ^ @*@, the kind of types+ | KindBang l -- ^ @!@, the kind of unboxed types+ | KindFn l (Kind l) (Kind l) -- ^ @->@, the kind of a type constructor+ | KindParen l (Kind l) -- ^ a parenthesised kind+ | KindVar l (Name l) -- ^ a kind variable (as-of-yet unsupported by compilers)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A functional dependency, given on the form+-- l1 l2 ... ln -> r2 r3 .. rn+data FunDep l+ = FunDep l [Name l] [Name l]+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A context is a set of assertions+data Context l+ = CxSingle l (Asst l)+ | CxTuple l [Asst l]+ | CxParen l (Context l)+ | CxEmpty l+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Class assertions.+-- In Haskell 98, the argument would be a /tyvar/, but this definition+-- allows multiple parameters, and allows them to be /type/s.+-- Also extended with support for implicit parameters and equality constraints.+data Asst l+ = ClassA l (QName l) [Type l] -- ^ ordinary class assertion+ | InfixA l (Type l) (QName l) (Type l) -- ^ class assertion where the class name is given infix+ | IParam l (IPName l) (Type l) -- ^ implicit parameter assertion+ | EqualP l (Type l) (Type l) -- ^ type equality constraint+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | /literal/+-- Values of this type hold the abstract value of the literal, along with the+-- precise string representation used. For example, @10@, @0o12@ and @0xa@+-- have the same value representation, but each carry a different string representation.+data Literal l+ = Char l Char String -- ^ character literal+ | String l String String -- ^ string literal+ | Int l Integer String -- ^ integer literal+ | Frac l Rational String -- ^ floating point literal+ | PrimInt l Integer String -- ^ unboxed integer literal+ | PrimWord l Integer String -- ^ unboxed word literal+ | PrimFloat l Rational String -- ^ unboxed float literal+ | PrimDouble l Rational String -- ^ unboxed double literal+ | PrimChar l Char String -- ^ unboxed character literal+ | PrimString l String String -- ^ unboxed string literal+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Haskell expressions.+data Exp l+ = Var l (QName l) -- ^ variable+ | FreeSectSlot l -- ^ FreeSect placeholder: @__@+ | IPVar l (IPName l) -- ^ implicit parameter variable+ | Con l (QName l) -- ^ data constructor+ | Lit l (Literal l) -- ^ literal constant+ | InfixApp l (Exp l) (QOp l) (Exp l) -- ^ infix application+ | App l (Exp l) (Exp l) -- ^ ordinary application+ | NegApp l (Exp l) -- ^ negation expression @-/exp/@ (unary minus)+ | Lambda l [Pat l] (Exp l) -- ^ lambda expression+ | Let l (Binds l) (Exp l) -- ^ local declarations with @let@ ... @in@ ...+ | If l (Exp l) (Exp l) (Exp l) -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/+ | Case l (Exp l) [Alt l] -- ^ @case@ /exp/ @of@ /alts/+ | Do l [Stmt l] -- ^ @do@-expression:+ -- the last statement in the list+ -- should be an expression.+ | MDo l [Stmt l] -- ^ @mdo@-expression+ | Tuple l [Exp l] -- ^ tuple expression+ | TupleSection l [Maybe (Exp l)] -- ^ tuple section expression, e.g. @(,,3)@+ | List l [Exp l] -- ^ list expression+ | FSContext l (Exp l) -- ^ FreeSect context grouping+ | Paren l (Exp l) -- ^ parenthesised expression+ | LeftSection l (Exp l) (QOp l) -- ^ left section @(@/exp/ /qop/@)@+ | RightSection l (QOp l) (Exp l) -- ^ right section @(@/qop/ /exp/@)@+ | RecConstr l (QName l) [FieldUpdate l] -- ^ record construction expression+ | RecUpdate l (Exp l) [FieldUpdate l] -- ^ record update expression+ | EnumFrom l (Exp l) -- ^ unbounded arithmetic sequence,+ -- incrementing by 1: @[from ..]@+ | EnumFromTo l (Exp l) (Exp l) -- ^ bounded arithmetic sequence,+ -- incrementing by 1 @[from .. to]@+ | EnumFromThen l (Exp l) (Exp l) -- ^ unbounded arithmetic sequence,+ -- with first two elements given @[from, then ..]@+ | EnumFromThenTo l (Exp l) (Exp l) (Exp l)+ -- ^ bounded arithmetic sequence,+ -- with first two elements given @[from, then .. to]@+ | ListComp l (Exp l) [QualStmt l] -- ^ ordinary list comprehension+ | ParComp l (Exp l) [[QualStmt l]] -- ^ parallel list comprehension+ | ExpTypeSig l (Exp l) (Type l) -- ^ expression with explicit type signature++ | VarQuote l (QName l) -- ^ @'x@ for template haskell reifying of expressions+ | TypQuote l (QName l) -- ^ @''T@ for template haskell reifying of types+ | BracketExp l (Bracket l) -- ^ template haskell bracket expression+ | SpliceExp l (Splice l) -- ^ template haskell splice expression+ | QuasiQuote l String String -- ^ quasi-quotaion: @[$/name/| /string/ |]@++-- Hsx+ | XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]+ -- ^ xml element, with attributes and children+ | XETag l (XName l) [XAttr l] (Maybe (Exp l))+ -- ^ empty xml element, with attributes+ | XPcdata l String -- ^ PCDATA child element+ | XExpTag l (Exp l) -- ^ escaped haskell expression inside xml+ | XChildTag l [Exp l] -- ^ children of an xml element +++-- Pragmas+ | CorePragma l String (Exp l) -- ^ CORE pragma+ | SCCPragma l String (Exp l) -- ^ SCC pragma+ | GenPragma l String (Int, Int) (Int, Int) (Exp l)+ -- ^ GENERATED pragma++-- Arrows+ | Proc l (Pat l) (Exp l) -- ^ arrows proc: @proc@ /pat/ @->@ /exp/+ | LeftArrApp l (Exp l) (Exp l) -- ^ arrow application (from left): /exp/ @-<@ /exp/+ | RightArrApp l (Exp l) (Exp l) -- ^ arrow application (from right): /exp/ @>-@ /exp/+ | LeftArrHighApp l (Exp l) (Exp l) -- ^ higher-order arrow application (from left): /exp/ @-<<@ /exp/+ | RightArrHighApp l (Exp l) (Exp l) -- ^ higher-order arrow application (from right): /exp/ @>>-@ /exp/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The name of an xml element or attribute,+-- possibly qualified with a namespace.+data XName l+ = XName l String -- <name ...+ | XDomName l String String -- <dom:name ...+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An xml attribute, which is a name-expression pair.+data XAttr l = XAttr l (XName l) (Exp l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A template haskell bracket expression.+data Bracket l+ = ExpBracket l (Exp l) -- ^ expression bracket: @[| ... |]@+ | PatBracket l (Pat l) -- ^ pattern bracket: @[p| ... |]@+ | TypeBracket l (Type l) -- ^ type bracket: @[t| ... |]@+ | DeclBracket l [Decl l] -- ^ declaration bracket: @[d| ... |]@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A template haskell splice expression+data Splice l+ = IdSplice l String -- ^ variable splice: @$var@+ | ParenSplice l (Exp l) -- ^ parenthesised expression splice: @$(/exp/)@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The safety of a foreign function call.+data Safety l+ = PlayRisky l -- ^ unsafe+ | PlaySafe l Bool -- ^ safe ('False') or threadsafe ('True')+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The calling convention of a foreign function call.+data CallConv l+ = StdCall l+ | CCall l+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A top level options pragma, preceding the module header.+data ModulePragma l+ = LanguagePragma l [Name l] -- ^ LANGUAGE pragma+ | OptionsPragma l (Maybe Tool) String+ -- ^ OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC+ | AnnModulePragma l (Annotation l)+ -- ^ ANN pragma with module scope+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Recognised tools for OPTIONS pragmas.+data Tool = GHC | HUGS | NHC98 | YHC | HADDOCK | UnknownTool String+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Activation clause of a RULES pragma.+data Activation l+ = ActiveFrom l Int+ | ActiveUntil l Int+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The body of a RULES pragma.+data Rule l+ = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Variables used in a RULES pragma, optionally annotated with types+data RuleVar l+ = RuleVar l (Name l)+ | TypedRuleVar l (Name l) (Type l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Warning text to optionally use in the module header of e.g.+-- a deprecated module.+data WarningText l+ = DeprText l String+ | WarnText l String+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A pattern, to be matched against a value.+data Pat l+ = PVar l (Name l) -- ^ variable+ | PLit l (Literal l) -- ^ literal constant+ | PNeg l (Pat l) -- ^ negated pattern+ | PNPlusK l (Name l) Integer -- ^ n+k pattern+ | PInfixApp l (Pat l) (QName l) (Pat l) -- ^ pattern with an infix data constructor+ | PApp l (QName l) [Pat l] -- ^ data constructor and argument patterns+ | PTuple l [Pat l] -- ^ tuple pattern+ | PList l [Pat l] -- ^ list pattern+ | PParen l (Pat l) -- ^ parenthesized pattern+ | PRec l (QName l) [PatField l] -- ^ labelled pattern, record style+ | PAsPat l (Name l) (Pat l) -- ^ @\@@-pattern+ | PWildCard l -- ^ wildcard pattern: @_@+ | PIrrPat l (Pat l) -- ^ irrefutable pattern: @~/pat/@+ | PatTypeSig l (Pat l) (Type l) -- ^ pattern with type signature+ | PViewPat l (Exp l) (Pat l) -- ^ view patterns of the form @(/exp/ -> /pat/)@+ | PRPat l [RPat l] -- ^ regular list pattern+ | PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]+ -- ^ XML element pattern+ | PXETag l (XName l) [PXAttr l] (Maybe (Pat l))+ -- ^ XML singleton element pattern+ | PXPcdata l String -- ^ XML PCDATA pattern+ | PXPatTag l (Pat l) -- ^ XML embedded pattern+ | PXRPats l [RPat l] -- ^ XML regular list pattern+ | PExplTypeArg l (QName l) (Type l) -- ^ Explicit generics style type argument e.g. @f {| Int |} x = ...@+ | PQuasiQuote l String String -- ^ quasi quote pattern: @[$/name/| /string/ |]@+ | PBangPat l (Pat l) -- ^ strict (bang) pattern: @f !x = ...@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An XML attribute in a pattern.+data PXAttr l = PXAttr l (XName l) (Pat l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A regular pattern operator.+data RPatOp l+ = RPStar l -- ^ @*@ = 0 or more+ | RPStarG l -- ^ @*!@ = 0 or more, greedy+ | RPPlus l -- ^ @+@ = 1 or more+ | RPPlusG l -- ^ @+!@ = 1 or more, greedy+ | RPOpt l -- ^ @?@ = 0 or 1+ | RPOptG l -- ^ @?!@ = 0 or 1, greedy+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An entity in a regular pattern.+data RPat l+ = RPOp l (RPat l) (RPatOp l) -- ^ operator pattern, e.g. pat*+ | RPEither l (RPat l) (RPat l) -- ^ choice pattern, e.g. (1 | 2)+ | RPSeq l [RPat l] -- ^ sequence pattern, e.g. (| 1, 2, 3 |)+ | RPGuard l (Pat l) [Stmt l] -- ^ guarded pattern, e.g. (| p | p < 3 |)+ | RPCAs l (Name l) (RPat l) -- ^ non-linear variable binding, e.g. (foo\@:(1 | 2))*+ | RPAs l (Name l) (RPat l) -- ^ linear variable binding, e.g. foo\@(1 | 2)+ | RPParen l (RPat l) -- ^ parenthesised pattern, e.g. (2*)+ | RPPat l (Pat l) -- ^ an ordinary pattern+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /fpat/ in a labeled record pattern.+data PatField l+ = PFieldPat l (QName l) (Pat l) -- ^ ordinary label-pattern pair+ | PFieldPun l (Name l) -- ^ record field pun+ | PFieldWildcard l -- ^ record field wildcard+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A statement, representing both a /stmt/ in a @do@-expression,+-- an ordinary /qual/ in a list comprehension, as well as a /stmt/+-- in a pattern guard.+data Stmt l+ = Generator l (Pat l) (Exp l)+ -- ^ a generator: /pat/ @<-@ /exp/+ | Qualifier l (Exp l) -- ^ an /exp/ by itself: in a @do@-expression,+ -- an action whose result is discarded;+ -- in a list comprehension and pattern guard,+ -- a guard expression+ | LetStmt l (Binds l) -- ^ local bindings+ | RecStmt l [Stmt l] -- ^ a recursive binding group for arrows+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A general /transqual/ in a list comprehension,+-- which could potentially be a transform of the kind+-- enabled by TransformListComp.+data QualStmt l+ = QualStmt l (Stmt l) -- ^ an ordinary statement+ | ThenTrans l (Exp l) -- ^ @then@ /exp/+ | ThenBy l (Exp l) (Exp l) -- ^ @then@ /exp/ @by@ /exp/+ | GroupBy l (Exp l) -- ^ @then@ @group@ @by@ /exp/+ | GroupUsing l (Exp l) -- ^ @then@ @group@ @using@ /exp/+ | GroupByUsing l (Exp l) (Exp l) -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /fbind/ in a labeled construction or update expression.+data FieldUpdate l+ = FieldUpdate l (QName l) (Exp l) -- ^ ordinary label-expresion pair+ | FieldPun l (Name l) -- ^ record field pun+ | FieldWildcard l -- ^ record field wildcard+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /alt/ alternative in a @case@ expression.+data Alt l+ = Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l))+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The right-hand sides of a @case@ alternative,+-- which may be a single right-hand side or a+-- set of guarded ones.+data GuardedAlts l+ = UnGuardedAlt l (Exp l) -- ^ @->@ /exp/+ | GuardedAlts l [GuardedAlt l] -- ^ /gdpat/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A guarded case alternative @|@ /stmts/ @->@ /exp/.+data GuardedAlt l+ = GuardedAlt l [Stmt l] (Exp l)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-----------------------------------------------------------------------------+-- Builtin names.++prelude_mod, main_mod :: l -> ModuleName l+prelude_mod l = ModuleName l "Prelude"+main_mod l = ModuleName l "Main"++main_name :: l -> Name l+main_name l = Ident l "main"++unit_con_name :: l -> QName l+unit_con_name l = Special l (UnitCon l)++tuple_con_name :: l -> Boxed -> Int -> QName l+tuple_con_name l b i = Special l (TupleCon l b (i+1))++list_cons_name :: l -> QName l+list_cons_name l = Special l (Cons l)++unboxed_singleton_con_name :: l -> QName l+unboxed_singleton_con_name l = Special l (UnboxedSingleCon l)++unit_con :: l -> Exp l+unit_con l = Con l $ unit_con_name l++tuple_con :: l -> Boxed -> Int -> Exp l+tuple_con l b i = Con l (tuple_con_name l b i)++unboxed_singleton_con :: l -> Exp l+unboxed_singleton_con l = Con l (unboxed_singleton_con_name l)++as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: l -> Name l+as_name l = Ident l "as"+qualified_name l = Ident l "qualified"+hiding_name l = Ident l "hiding"+minus_name l = Symbol l "-"+bang_name l = Symbol l "!"+dot_name l = Symbol l "."+star_name l = Symbol l "*"++export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name :: l -> Name l+export_name l = Ident l "export"+safe_name l = Ident l "safe"+unsafe_name l = Ident l "unsafe"+threadsafe_name l = Ident l "threadsafe"+stdcall_name l = Ident l "stdcall"+ccall_name l = Ident l "ccall"++unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: l -> QName l+unit_tycon_name l = unit_con_name l+fun_tycon_name l = Special l (FunCon l)+list_tycon_name l = Special l (ListCon l)+unboxed_singleton_tycon_name l = Special l (UnboxedSingleCon l)++tuple_tycon_name :: l -> Boxed -> Int -> QName l+tuple_tycon_name l b i = tuple_con_name l b i++unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> Type l+unit_tycon l = TyCon l $ unit_tycon_name l+fun_tycon l = TyCon l $ fun_tycon_name l+list_tycon l = TyCon l $ list_tycon_name l+unboxed_singleton_tycon l = TyCon l $ unboxed_singleton_tycon_name l++tuple_tycon :: l -> Boxed -> Int -> Type l+tuple_tycon l b i = TyCon l (tuple_tycon_name l b i)++-----------------------------------------------------------------------------+-- AST traversal, boiler-plate style++-- | Test if two AST elements are equal modulo annotations.+(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool+a =~= b = fmap (const ()) a == fmap (const ()) b++instance Functor ModuleName where+ fmap f (ModuleName l s) = ModuleName (f l) s++instance Functor SpecialCon where+ fmap f sc = case sc of+ UnitCon l -> UnitCon (f l)+ ListCon l -> ListCon (f l)+ FunCon l -> FunCon (f l)+ TupleCon l b n -> TupleCon (f l) b n+ Cons l -> Cons (f l)+ UnboxedSingleCon l -> UnboxedSingleCon (f l)++instance Functor QName where+ fmap f qn = case qn of+ Qual l mn n -> Qual (f l) (fmap f mn) (fmap f n)+ UnQual l n -> UnQual (f l) (fmap f n)+ Special l sc -> Special (f l) (fmap f sc)++instance Functor Name where+ fmap f (Ident l s) = Ident (f l) s+ fmap f (Symbol l s) = Symbol (f l) s++instance Functor IPName where+ fmap f (IPDup l s) = IPDup (f l) s+ fmap f (IPLin l s) = IPLin (f l) s++instance Functor QOp where+ fmap f (QVarOp l qn) = QVarOp (f l) (fmap f qn)+ fmap f (QConOp l qn) = QConOp (f l) (fmap f qn)++instance Functor Op where+ fmap f (VarOp l n) = VarOp (f l) (fmap f n)+ fmap f (ConOp l n) = ConOp (f l) (fmap f n)++instance Functor CName where+ fmap f (VarName l n) = VarName (f l) (fmap f n)+ fmap f (ConName l n) = ConName (f l) (fmap f n)++instance Functor Module where+ fmap f (Module l mmh ops iss dcls) =+ Module (f l) (fmap (fmap f) mmh) (map (fmap f) ops) (map (fmap f) iss) (map (fmap f) dcls)+ fmap f (XmlPage l mn os xn xas me es) =+ XmlPage (f l) (fmap f mn) (map (fmap f) os) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es)+ fmap f (XmlHybrid l mmh ops iss dcls xn xas me es) =+ XmlHybrid (f l) (fmap (fmap f) mmh) (map (fmap f) ops) (map (fmap f) iss) (map (fmap f) dcls)+ (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es)++instance Functor ModuleHead where+ fmap f (ModuleHead l mn mwt mexpl) =+ ModuleHead (f l) (fmap f mn) (fmap (fmap f) mwt) (fmap (fmap f) mexpl)++instance Functor ExportSpecList where+ fmap f (ExportSpecList l ess) = ExportSpecList (f l) (map (fmap f) ess)++instance Functor ExportSpec where+ fmap f es = case es of+ EVar l qn -> EVar (f l) (fmap f qn)+ EAbs l qn -> EAbs (f l) (fmap f qn)+ EThingAll l qn -> EThingAll (f l) (fmap f qn)+ EThingWith l qn cns -> EThingWith (f l) (fmap f qn) (map (fmap f) cns)+ EModuleContents l mn -> EModuleContents (f l) (fmap f mn)++instance Functor ImportDecl where+ fmap f (ImportDecl l mn qual src pkg mmn mis) =+ ImportDecl (f l) (fmap f mn) qual src pkg (fmap (fmap f) mmn) (fmap (fmap f) mis)++instance Functor ImportSpecList where+ fmap f (ImportSpecList l b iss) = ImportSpecList (f l) b (map (fmap f) iss)++instance Functor ImportSpec where+ fmap f is = case is of+ IVar l n -> IVar (f l) (fmap f n)+ IAbs l n -> IAbs (f l) (fmap f n)+ IThingAll l n -> IThingAll (f l) (fmap f n)+ IThingWith l n cns -> IThingWith (f l) (fmap f n) (map (fmap f) cns)++instance Functor Assoc where+ fmap f (AssocNone l) = AssocNone (f l)+ fmap f (AssocLeft l) = AssocLeft (f l)+ fmap f (AssocRight l) = AssocRight (f l)++instance Functor Decl where+ fmap f decl = case decl of+ TypeDecl l dh t -> TypeDecl (f l) (fmap f dh) (fmap f t)+ TypeFamDecl l dh mk -> TypeFamDecl (f l) (fmap f dh) (fmap (fmap f) mk)+ DataDecl l dn mcx dh cds ders ->+ DataDecl (f l) (fmap f dn) (fmap (fmap f) mcx) (fmap f dh) (map (fmap f) cds) (fmap (fmap f) ders)+ GDataDecl l dn mcx dh mk gds ders ->+ GDataDecl (f l) (fmap f dn) (fmap (fmap f) mcx) (fmap f dh) (fmap (fmap f) mk) (map (fmap f) gds) (fmap (fmap f) ders)+ DataFamDecl l mcx dh mk -> DataFamDecl (f l) (fmap (fmap f) mcx) (fmap f dh) (fmap (fmap f) mk)+ TypeInsDecl l t1 t2 -> TypeInsDecl (f l) (fmap f t1) (fmap f t2)+ DataInsDecl l dn t cds ders -> DataInsDecl (f l) (fmap f dn) (fmap f t) (map (fmap f) cds) (fmap (fmap f) ders)+ GDataInsDecl l dn t mk gds ders -> GDataInsDecl (f l) (fmap f dn) (fmap f t) (fmap (fmap f) mk) (map (fmap f) gds) (fmap (fmap f) ders)+ ClassDecl l mcx dh fds mcds -> ClassDecl (f l) (fmap (fmap f) mcx) (fmap f dh) (map (fmap f) fds) (fmap (map (fmap f)) mcds)+ InstDecl l mcx ih mids -> InstDecl (f l) (fmap (fmap f) mcx) (fmap f ih) (fmap (map (fmap f)) mids)+ DerivDecl l mcx ih -> DerivDecl (f l) (fmap (fmap f) mcx) (fmap f ih)+ InfixDecl l a k ops -> InfixDecl (f l) (fmap f a) k (map (fmap f) ops)+ DefaultDecl l ts -> DefaultDecl (f l) (map (fmap f) ts)+ SpliceDecl l sp -> SpliceDecl (f l) (fmap f sp)+ TypeSig l ns t -> TypeSig (f l) (map (fmap f) ns) (fmap f t)+ FunBind l ms -> FunBind (f l) (map (fmap f) ms)+ PatBind l p mt rhs bs -> PatBind (f l) (fmap f p) (fmap (fmap f) mt) (fmap f rhs) (fmap (fmap f) bs)+ ForImp l cc msf s n t -> ForImp (f l) (fmap f cc) (fmap (fmap f) msf) s (fmap f n) (fmap f t)+ ForExp l cc s n t -> ForExp (f l) (fmap f cc) s (fmap f n) (fmap f t)+ RulePragmaDecl l rs -> RulePragmaDecl (f l) (map (fmap f) rs)+ DeprPragmaDecl l nss -> DeprPragmaDecl (f l) (map (wp f) nss)+ WarnPragmaDecl l nss -> WarnPragmaDecl (f l) (map (wp f) nss)+ InlineSig l b mact qn -> InlineSig (f l) b (fmap (fmap f) mact) (fmap f qn)+ InlineConlikeSig l mact qn -> InlineConlikeSig (f l) (fmap (fmap f) mact) (fmap f qn)+ SpecInlineSig l b mact qn ts -> SpecInlineSig (f l) b (fmap (fmap f) mact) (fmap f qn) (map (fmap f) ts)+ SpecSig l qn ts -> SpecSig (f l) (fmap f qn) (map (fmap f) ts)+ InstSig l mcx ih -> InstSig (f l) (fmap (fmap f) mcx) (fmap f ih)+ AnnPragma l ann -> AnnPragma (f l) (fmap f ann)+ where wp f (ns, s) = (map (fmap f) ns, s)++instance Functor Annotation where+ fmap f (Ann l n e) = Ann (f l) (fmap f n) (fmap f e)+ fmap f (TypeAnn l n e) = TypeAnn (f l) (fmap f n) (fmap f e)+ fmap f (ModuleAnn l e) = ModuleAnn (f l) (fmap f e)++instance Functor DataOrNew where+ fmap f (DataType l) = DataType (f l)+ fmap f (NewType l) = NewType (f l)++instance Functor DeclHead where+ fmap f (DHead l n tvs) = DHead (f l) (fmap f n) (map (fmap f) tvs)+ fmap f (DHInfix l tva n tvb) = DHInfix (f l) (fmap f tva) (fmap f n) (fmap f tvb)+ fmap f (DHParen l dh) = DHParen (f l) (fmap f dh)++instance Functor InstHead where+ fmap f (IHead l qn ts) = IHead (f l) (fmap f qn) (map (fmap f) ts)+ fmap f (IHInfix l ta qn tb) = IHInfix (f l) (fmap f ta) (fmap f qn) (fmap f tb)+ fmap f (IHParen l ih) = IHParen (f l) (fmap f ih)++instance Functor Deriving where+ fmap f (Deriving l ihs) = Deriving (f l) (map (fmap f) ihs)++instance Functor Binds where+ fmap f (BDecls l decls) = BDecls (f l) (map (fmap f) decls)+ fmap f (IPBinds l ibs) = IPBinds (f l) (map (fmap f) ibs)++instance Functor IPBind where+ fmap f (IPBind l ipn e) = IPBind (f l) (fmap f ipn) (fmap f e)++instance Functor Match where+ fmap f (Match l n ps rhs bs) =+ Match (f l) (fmap f n) (map (fmap f) ps) (fmap f rhs) (fmap (fmap f) bs)+ fmap f (InfixMatch l a n ps rhs bs) =+ InfixMatch (f l) (fmap f a) (fmap f n) (map (fmap f) ps) (fmap f rhs) (fmap (fmap f) bs)++instance Functor QualConDecl where+ fmap f (QualConDecl l mtvs mcx cd) = QualConDecl (f l) (fmap (map (fmap f)) mtvs) (fmap (fmap f) mcx) (fmap f cd)++instance Functor ConDecl where+ fmap f (ConDecl l n bts) = ConDecl (f l) (fmap f n) (map (fmap f) bts)+ fmap f (InfixConDecl l ta n tb) = InfixConDecl (f l) (fmap f ta) (fmap f n) (fmap f tb)+ fmap f (RecDecl l n fds) = RecDecl (f l) (fmap f n) (map (fmap f) fds)++instance Functor FieldDecl where+ fmap f (FieldDecl l ns t) = FieldDecl (f l) (map (fmap f) ns) (fmap f t)++instance Functor GadtDecl where+ fmap f (GadtDecl l n t) = GadtDecl (f l) (fmap f n) (fmap f t)++instance Functor ClassDecl where+ fmap f (ClsDecl l d) = ClsDecl (f l) (fmap f d)+ fmap f (ClsDataFam l mcx dh mk) = ClsDataFam (f l) (fmap (fmap f) mcx) (fmap f dh) (fmap (fmap f) mk)+ fmap f (ClsTyFam l dh mk) = ClsTyFam (f l) (fmap f dh) (fmap (fmap f) mk)+ fmap f (ClsTyDef l t1 t2) = ClsTyDef (f l) (fmap f t1) (fmap f t2)++instance Functor InstDecl where+ fmap f id = case id of+ InsDecl l d -> InsDecl (f l) (fmap f d)+ InsType l t1 t2 -> InsType (f l) (fmap f t1) (fmap f t2)+ InsData l dn t cds ders+ -> InsData (f l) (fmap f dn) (fmap f t) (map (fmap f) cds) (fmap (fmap f) ders)+ InsGData l dn t mk gds ders+ -> InsGData (f l) (fmap f dn) (fmap f t) (fmap (fmap f) mk) (map (fmap f) gds) (fmap (fmap f) ders)+-- InsInline l b mact qn -> InsInline (f l) b (fmap (fmap f) mact) (fmap f qn)++instance Functor BangType where+ fmap f (BangedTy l t) = BangedTy (f l) (fmap f t)+ fmap f (UnBangedTy l t) = UnBangedTy (f l) (fmap f t)+ fmap f (UnpackedTy l t) = UnpackedTy (f l) (fmap f t)++instance Functor Rhs where+ fmap f (UnGuardedRhs l e) = UnGuardedRhs (f l) (fmap f e)+ fmap f (GuardedRhss l grhss) = GuardedRhss (f l) (map (fmap f) grhss)++instance Functor GuardedRhs where+ fmap f (GuardedRhs l ss e) = GuardedRhs (f l) (map (fmap f) ss) (fmap f e)++instance Functor Type where+ fmap f t = case t of+ TyForall l mtvs mcx t -> TyForall (f l) (fmap (map (fmap f)) mtvs) (fmap (fmap f) mcx) (fmap f t)+ TyFun l t1 t2 -> TyFun (f l) (fmap f t1) (fmap f t2)+ TyTuple l b ts -> TyTuple (f l) b (map (fmap f) ts)+ TyList l t -> TyList (f l) (fmap f t)+ TyApp l t1 t2 -> TyApp (f l) (fmap f t1) (fmap f t2)+ TyVar l n -> TyVar (f l) (fmap f n)+ TyCon l qn -> TyCon (f l) (fmap f qn)+ TyParen l t -> TyParen (f l) (fmap f t)+ TyInfix l ta qn tb -> TyInfix (f l) (fmap f ta) (fmap f qn) (fmap f tb)+ TyKind l t k -> TyKind (f l) (fmap f t) (fmap f k)++instance Functor TyVarBind where+ fmap f (KindedVar l n k) = KindedVar (f l) (fmap f n) (fmap f k)+ fmap f (UnkindedVar l n) = UnkindedVar (f l) (fmap f n)++instance Functor Kind where+ fmap f (KindStar l) = KindStar (f l)+ fmap f (KindBang l) = KindBang (f l)+ fmap f (KindFn l k1 k2) = KindFn (f l) (fmap f k1) (fmap f k2)+ fmap f (KindParen l k) = KindParen (f l) (fmap f k)+ fmap f (KindVar l n) = KindVar (f l) (fmap f n)++instance Functor FunDep where+ fmap f (FunDep l ns1 ns2) = FunDep (f l) (map (fmap f) ns1) (map (fmap f) ns2)++instance Functor Context where+ fmap f (CxSingle l asst) = CxSingle (f l) (fmap f asst)+ fmap f (CxTuple l assts) = CxTuple (f l) (map (fmap f) assts)+ fmap f (CxParen l ctxt) = CxParen (f l) (fmap f ctxt)+ fmap f (CxEmpty l) = CxEmpty (f l)++instance Functor Asst where+ fmap f asst = case asst of+ ClassA l qn ts -> ClassA (f l) (fmap f qn) (map (fmap f) ts)+ InfixA l ta qn tb -> InfixA (f l) (fmap f ta) (fmap f qn) (fmap f tb)+ IParam l ipn t -> IParam (f l) (fmap f ipn) (fmap f t)+ EqualP l t1 t2 -> EqualP (f l) (fmap f t1) (fmap f t2)++instance Functor Literal where+ fmap f lit = case lit of+ Char l c rw -> Char (f l) c rw+ String l s rw -> String (f l) s rw+ Int l i rw -> Int (f l) i rw+ Frac l r rw -> Frac (f l) r rw+ PrimInt l i rw -> PrimInt (f l) i rw+ PrimWord l i rw -> PrimWord (f l) i rw+ PrimFloat l r rw -> PrimFloat (f l) r rw+ PrimDouble l r rw -> PrimDouble (f l) r rw+ PrimChar l c rw -> PrimChar (f l) c rw+ PrimString l s rw -> PrimString (f l) s rw++instance Functor Exp where+ fmap f e = case e of+ Var l qn -> Var (f l) (fmap f qn)+ FreeSectSlot l -> FreeSectSlot (f l)+ IPVar l ipn -> IPVar (f l) (fmap f ipn)+ Con l qn -> Con (f l) (fmap f qn)+ Lit l lit -> Lit (f l) (fmap f lit)+ InfixApp l e1 qop e2 -> InfixApp (f l) (fmap f e1) (fmap f qop) (fmap f e2)+ App l e1 e2 -> App (f l) (fmap f e1) (fmap f e2)+ NegApp l e -> NegApp (f l) (fmap f e)+ Lambda l ps e -> Lambda (f l) (map (fmap f) ps) (fmap f e)+ Let l bs e -> Let (f l) (fmap f bs) (fmap f e)+ If l ec et ee -> If (f l) (fmap f ec) (fmap f et) (fmap f ee)+ Case l e alts -> Case (f l) (fmap f e) (map (fmap f) alts)+ Do l ss -> Do (f l) (map (fmap f) ss)+ MDo l ss -> MDo (f l) (map (fmap f) ss)+ Tuple l es -> Tuple (f l) (map (fmap f) es)+ TupleSection l mes -> TupleSection (f l) (map (fmap (fmap f)) mes)+ List l es -> List (f l) (map (fmap f) es)+ FSContext l e -> FSContext (f l) (fmap f e)+ Paren l e -> Paren (f l) (fmap f e)+ LeftSection l e qop -> LeftSection (f l) (fmap f e) (fmap f qop)+ RightSection l qop e -> RightSection (f l) (fmap f qop) (fmap f e)+ RecConstr l qn fups -> RecConstr (f l) (fmap f qn) (map (fmap f) fups)+ RecUpdate l e fups -> RecUpdate (f l) (fmap f e) (map (fmap f) fups)+ EnumFrom l e -> EnumFrom (f l) (fmap f e)+ EnumFromTo l ef et -> EnumFromTo (f l) (fmap f ef) (fmap f et)+ EnumFromThen l ef et -> EnumFromThen (f l) (fmap f ef) (fmap f et)+ EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) (fmap f ef) (fmap f eth) (fmap f eto)+ ListComp l e qss -> ListComp (f l) (fmap f e) (map (fmap f) qss)+ ParComp l e qsss -> ParComp (f l) (fmap f e) (map (map (fmap f)) qsss)+ ExpTypeSig l e t -> ExpTypeSig (f l) (fmap f e) (fmap f t)+ VarQuote l qn -> VarQuote (f l) (fmap f qn)+ TypQuote l qn -> TypQuote (f l) (fmap f qn)+ BracketExp l br -> BracketExp (f l) (fmap f br)+ SpliceExp l sp -> SpliceExp (f l) (fmap f sp)+ QuasiQuote l sn se -> QuasiQuote (f l) sn se++ XTag l xn xas me es -> XTag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es)+ XETag l xn xas me -> XETag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me)+ XPcdata l s -> XPcdata (f l) s+ XExpTag l e -> XExpTag (f l) (fmap f e)+ XChildTag l es -> XChildTag (f l) (map (fmap f) es)++ CorePragma l s e -> CorePragma (f l) s (fmap f e)+ SCCPragma l s e -> SCCPragma (f l) s (fmap f e)+ GenPragma l s n12 n34 e -> GenPragma (f l) s n12 n34 (fmap f e)++ Proc l p e -> Proc (f l) (fmap f p) (fmap f e)+ LeftArrApp l e1 e2 -> LeftArrApp (f l) (fmap f e1) (fmap f e2)+ RightArrApp l e1 e2 -> RightArrApp (f l) (fmap f e1) (fmap f e2)+ LeftArrHighApp l e1 e2 -> LeftArrHighApp (f l) (fmap f e1) (fmap f e2)+ RightArrHighApp l e1 e2 -> RightArrHighApp (f l) (fmap f e1) (fmap f e2)++instance Functor XName where+ fmap f (XName l s) = XName (f l) s+ fmap f (XDomName l sd sn) = XDomName (f l) sd sn++instance Functor XAttr where+ fmap f (XAttr l xn e) = XAttr (f l) (fmap f xn) (fmap f e)++instance Functor Bracket where+ fmap f (ExpBracket l e) = ExpBracket (f l) (fmap f e)+ fmap f (PatBracket l p) = PatBracket (f l) (fmap f p)+ fmap f (TypeBracket l t) = TypeBracket (f l) (fmap f t)+ fmap f (DeclBracket l ds) = DeclBracket (f l) (map (fmap f) ds)++instance Functor Splice where+ fmap f (IdSplice l s) = IdSplice (f l) s+ fmap f (ParenSplice l e) = ParenSplice (f l) (fmap f e)++instance Functor Safety where+ fmap f (PlayRisky l) = PlayRisky (f l)+ fmap f (PlaySafe l b) = PlaySafe (f l) b++instance Functor CallConv where+ fmap f (StdCall l) = StdCall (f l)+ fmap f (CCall l) = CCall (f l)++instance Functor ModulePragma where+ fmap f (LanguagePragma l ns) = LanguagePragma (f l) (map (fmap f) ns)+ fmap f (OptionsPragma l mt s) = OptionsPragma (f l) mt s+ fmap f (AnnModulePragma l ann) = AnnModulePragma (f l) (fmap f ann)++instance Functor Activation where+ fmap f (ActiveFrom l k) = ActiveFrom (f l) k+ fmap f (ActiveUntil l k) = ActiveUntil (f l) k++instance Functor Rule where+ fmap f (Rule l s mact mrvs e1 e2) =+ Rule (f l) s (fmap (fmap f) mact) (fmap (map (fmap f)) mrvs) (fmap f e1) (fmap f e2)++instance Functor RuleVar where+ fmap f (RuleVar l n) = RuleVar (f l) (fmap f n)+ fmap f (TypedRuleVar l n t) = TypedRuleVar (f l) (fmap f n) (fmap f t)++instance Functor WarningText where+ fmap f (DeprText l s) = DeprText (f l) s+ fmap f (WarnText l s) = WarnText (f l) s++instance Functor Pat where+ fmap f p = case p of+ PVar l n -> PVar (f l) (fmap f n)+ PLit l lit -> PLit (f l) (fmap f lit)+ PNeg l p -> PNeg (f l) (fmap f p)+ PNPlusK l n k -> PNPlusK (f l) (fmap f n) k+ PInfixApp l pa qn pb -> PInfixApp (f l) (fmap f pa) (fmap f qn) (fmap f pb)+ PApp l qn ps -> PApp (f l) (fmap f qn) (map (fmap f) ps)+ PTuple l ps -> PTuple (f l) (map (fmap f) ps)+ PList l ps -> PList (f l) (map (fmap f) ps)+ PParen l p -> PParen (f l) (fmap f p)+ PRec l qn pfs -> PRec (f l) (fmap f qn) (map (fmap f) pfs)+ PAsPat l n p -> PAsPat (f l) (fmap f n) (fmap f p)+ PWildCard l -> PWildCard (f l)+ PIrrPat l p -> PIrrPat (f l) (fmap f p)+ PatTypeSig l p t -> PatTypeSig (f l) (fmap f p) (fmap f t)+ PViewPat l e p -> PViewPat (f l) (fmap f e) (fmap f p)+ PRPat l rps -> PRPat (f l) (map (fmap f) rps)+ PXTag l xn pxas mp ps -> PXTag (f l) (fmap f xn) (map (fmap f) pxas) (fmap (fmap f) mp) (map (fmap f) ps)+ PXETag l xn pxas mp -> PXETag (f l) (fmap f xn) (map (fmap f) pxas) (fmap (fmap f) mp)+ PXPcdata l s -> PXPcdata (f l) s+ PXPatTag l p -> PXPatTag (f l) (fmap f p)+ PXRPats l rps -> PXRPats (f l) (map (fmap f) rps)+ PExplTypeArg l qn t -> PExplTypeArg (f l) (fmap f qn) (fmap f t)+ PQuasiQuote l sn st -> PQuasiQuote (f l) sn st+ PBangPat l p -> PBangPat (f l) (fmap f p)++instance Functor PXAttr where+ fmap f (PXAttr l xn p) = PXAttr (f l) (fmap f xn) (fmap f p)++instance Functor RPatOp where+ fmap f (RPStar l) = RPStar (f l)+ fmap f (RPStarG l) = RPStarG (f l)+ fmap f (RPPlus l) = RPPlus (f l)+ fmap f (RPPlusG l) = RPPlusG (f l)+ fmap f (RPOpt l) = RPOpt (f l)+ fmap f (RPOptG l) = RPOptG (f l)++instance Functor RPat where+ fmap f rp = case rp of+ RPOp l rp rop -> RPOp (f l) (fmap f rp) (fmap f rop)+ RPEither l rp1 rp2 -> RPEither (f l) (fmap f rp1) (fmap f rp2)+ RPSeq l rps -> RPSeq (f l) (map (fmap f) rps)+ RPGuard l p ss -> RPGuard (f l) (fmap f p) (map (fmap f) ss)+ RPCAs l n rp -> RPCAs (f l) (fmap f n) (fmap f rp)+ RPAs l n rp -> RPAs (f l) (fmap f n) (fmap f rp)+ RPParen l rp -> RPParen (f l) (fmap f rp)+ RPPat l p -> RPPat (f l) (fmap f p)++instance Functor PatField where+ fmap f (PFieldPat l qn p) = PFieldPat (f l) (fmap f qn) (fmap f p)+ fmap f (PFieldPun l n) = PFieldPun (f l) (fmap f n)+ fmap f (PFieldWildcard l) = PFieldWildcard (f l)++instance Functor Stmt where+ fmap f (Generator l p e) = Generator (f l) (fmap f p) (fmap f e)+ fmap f (Qualifier l e) = Qualifier (f l) (fmap f e)+ fmap f (LetStmt l bs) = LetStmt (f l) (fmap f bs)+ fmap f (RecStmt l ss) = RecStmt (f l) (map (fmap f) ss)++instance Functor QualStmt where+ fmap f (QualStmt l s) = QualStmt (f l) (fmap f s)+ fmap f (ThenTrans l e) = ThenTrans (f l) (fmap f e)+ fmap f (ThenBy l e1 e2) = ThenBy (f l) (fmap f e1) (fmap f e2)+ fmap f (GroupBy l e) = GroupBy (f l) (fmap f e)+ fmap f (GroupUsing l e) = GroupUsing (f l) (fmap f e)+ fmap f (GroupByUsing l e1 e2) = GroupByUsing (f l) (fmap f e1) (fmap f e2)++instance Functor FieldUpdate where+ fmap f (FieldUpdate l qn e) = FieldUpdate (f l) (fmap f qn) (fmap f e)+ fmap f (FieldPun l n) = FieldPun (f l) (fmap f n)+ fmap f (FieldWildcard l) = FieldWildcard (f l)++instance Functor Alt where+ fmap f (Alt l p gs bs) = Alt (f l) (fmap f p) (fmap f gs) (fmap (fmap f) bs)++instance Functor GuardedAlts where+ fmap f (UnGuardedAlt l e) = UnGuardedAlt (f l) (fmap f e)+ fmap f (GuardedAlts l galts) = GuardedAlts (f l) (map (fmap f) galts)++instance Functor GuardedAlt where+ fmap f (GuardedAlt l ss e) = GuardedAlt (f l) (map (fmap f) ss) (fmap f e)++-----------------------------------------------------------------------------+-- Reading annotations++-- | AST nodes are annotated, and this class allows manipulation of the annotations.+class Functor ast => Annotated ast where+ -- | Retrieve the annotation of an AST node.+ ann :: ast l -> l+ -- | Change the annotation of an AST node. Note that only the annotation of+ -- the node itself is affected, and not the annotations of any child nodes.+ -- if all nodes in the AST tree are to be affected, use 'fmap'.+ amap :: (l -> l) -> ast l -> ast l++instance Annotated ModuleName where+ ann (ModuleName l _) = l+ amap f (ModuleName l n) = ModuleName (f l) n++instance Annotated SpecialCon where+ ann sc = case sc of+ UnitCon l -> l+ ListCon l -> l+ FunCon l -> l+ TupleCon l _ _ -> l+ Cons l -> l+ UnboxedSingleCon l -> l+ amap = fmap++instance Annotated QName where+ ann qn = case qn of+ Qual l mn n -> l+ UnQual l n -> l+ Special l sc -> l+ amap f qn = case qn of+ Qual l mn n -> Qual (f l) mn n+ UnQual l n -> UnQual (f l) n+ Special l sc -> Special (f l) sc++instance Annotated Name where+ ann (Ident l s) = l+ ann (Symbol l s) = l+ amap = fmap++instance Annotated IPName where+ ann (IPDup l s) = l+ ann (IPLin l s) = l+ amap = fmap++instance Annotated QOp where+ ann (QVarOp l qn) = l+ ann (QConOp l qn) = l+ amap f (QVarOp l qn) = QVarOp (f l) qn+ amap f (QConOp l qn) = QConOp (f l) qn++instance Annotated Op where+ ann (VarOp l n) = l+ ann (ConOp l n) = l+ amap f (VarOp l n) = VarOp (f l) n+ amap f (ConOp l n) = ConOp (f l) n++instance Annotated CName where+ ann (VarName l n) = l+ ann (ConName l n) = l+ amap f (VarName l n) = VarName (f l) n+ amap f (ConName l n) = ConName (f l) n++instance Annotated Module where+ ann (Module l mmh ops iss dcls) = l+ ann (XmlPage l mn os xn xas me es) = l+ ann (XmlHybrid l mmh ops iss dcls xn xas me es) = l++ amap f (Module l mmh ops iss dcls) =+ Module (f l) mmh ops iss dcls+ amap f (XmlPage l mn os xn xas me es) =+ XmlPage (f l) mn os xn xas me es+ amap f (XmlHybrid l mmh ops iss dcls xn xas me es) =+ XmlHybrid (f l) mmh ops iss dcls xn xas me es++instance Annotated ModuleHead where+ ann (ModuleHead l n mwt mesl) = l+ amap f (ModuleHead l n mwt mesl) = ModuleHead (f l) n mwt mesl++instance Annotated ExportSpecList where+ ann (ExportSpecList l ess) = l+ amap f (ExportSpecList l ess) = ExportSpecList (f l) ess++instance Annotated ExportSpec where+ ann es = case es of+ EVar l qn -> l+ EAbs l qn -> l+ EThingAll l qn -> l+ EThingWith l qn cns -> l+ EModuleContents l mn -> l+ amap f es = case es of+ EVar l qn -> EVar (f l) qn+ EAbs l qn -> EAbs (f l) qn+ EThingAll l qn -> EThingAll (f l) qn+ EThingWith l qn cns -> EThingWith (f l) qn cns+ EModuleContents l mn -> EModuleContents (f l) mn++instance Annotated ImportDecl where+ ann (ImportDecl l mn qual src pkg mmn mis) = l+ amap f (ImportDecl l mn qual src pkg mmn mis) =+ ImportDecl (f l) mn qual src pkg mmn mis++instance Annotated ImportSpecList where+ ann (ImportSpecList l b iss) = l+ amap f (ImportSpecList l b iss) = ImportSpecList (f l) b iss++instance Annotated ImportSpec where+ ann is = case is of+ IVar l n -> l+ IAbs l n -> l+ IThingAll l n -> l+ IThingWith l n cns -> l+ amap f is = case is of+ IVar l n -> IVar (f l) n+ IAbs l n -> IAbs (f l) n+ IThingAll l n -> IThingAll (f l) n+ IThingWith l n cns -> IThingWith (f l) n cns++instance Annotated Assoc where+ ann (AssocNone l) = l+ ann (AssocLeft l) = l+ ann (AssocRight l) = l+ amap = fmap++instance Annotated Deriving where+ ann (Deriving l ihs) = l+ amap f (Deriving l ihs) = Deriving (f l) ihs++instance Annotated Decl where+ ann decl = case decl of+ TypeDecl l dh t -> l+ TypeFamDecl l dh mk -> l+ DataDecl l dn cx dh cds ders -> l+ GDataDecl l dn cx dh mk gds ders -> l+ DataFamDecl l cx dh mk -> l+ TypeInsDecl l t1 t2 -> l+ DataInsDecl l dn t cds ders -> l+ GDataInsDecl l dn t mk gds ders -> l+ ClassDecl l cx dh fds cds -> l+ InstDecl l cx ih ids -> l+ DerivDecl l cx ih -> l+ InfixDecl l a k ops -> l+ DefaultDecl l ts -> l+ SpliceDecl l sp -> l+ TypeSig l ns t -> l+ FunBind l ms -> l+ PatBind l p mt rhs bs -> l+ ForImp l cc msf s n t -> l+ ForExp l cc s n t -> l+ RulePragmaDecl l rs -> l+ DeprPragmaDecl l nss -> l+ WarnPragmaDecl l nss -> l+ InlineSig l b act qn -> l+ InlineConlikeSig l act qn -> l+ SpecSig l qn ts -> l+ SpecInlineSig l b act qn ts -> l+ InstSig l cx ih -> l+ AnnPragma l ann -> l+ amap f decl = case decl of+ TypeDecl l dh t -> TypeDecl (f l) dh t+ TypeFamDecl l dh mk -> TypeFamDecl (f l) dh mk+ DataDecl l dn mcx dh cds ders ->+ DataDecl (f l) dn mcx dh cds ders+ GDataDecl l dn mcx dh mk gds ders ->+ GDataDecl (f l) dn mcx dh mk gds ders+ DataFamDecl l mcx dh mk -> DataFamDecl (f l) mcx dh mk+ TypeInsDecl l t1 t2 -> TypeInsDecl (f l) t1 t2+ DataInsDecl l dn t cds ders -> DataInsDecl (f l) dn t cds ders+ GDataInsDecl l dn t mk gds ders -> GDataInsDecl (f l) dn t mk gds ders+ ClassDecl l mcx dh fds cds -> ClassDecl (f l) mcx dh fds cds+ InstDecl l mcx ih ids -> InstDecl (f l) mcx ih ids+ DerivDecl l mcx ih -> DerivDecl (f l) mcx ih+ InfixDecl l a k ops -> InfixDecl (f l) a k ops+ DefaultDecl l ts -> DefaultDecl (f l) ts+ SpliceDecl l sp -> SpliceDecl (f l) sp+ TypeSig l ns t -> TypeSig (f l) ns t+ FunBind l ms -> FunBind (f l) ms+ PatBind l p mt rhs bs -> PatBind (f l) p mt rhs bs+ ForImp l cc msf s n t -> ForImp (f l) cc msf s n t+ ForExp l cc s n t -> ForExp (f l) cc s n t+ RulePragmaDecl l rs -> RulePragmaDecl (f l) rs+ DeprPragmaDecl l nss -> DeprPragmaDecl (f l) nss+ WarnPragmaDecl l nss -> WarnPragmaDecl (f l) nss+ InlineSig l b act qn -> InlineSig (f l) b act qn+ InlineConlikeSig l act qn -> InlineConlikeSig (f l) act qn+ SpecSig l qn ts -> SpecSig (f l) qn ts+ SpecInlineSig l b act qn ts -> SpecInlineSig (f l) b act qn ts+ InstSig l mcx ih -> InstSig (f l) mcx ih+ AnnPragma l ann -> AnnPragma (f l) ann++instance Annotated Annotation where+ ann (Ann l n e) = l+ ann (TypeAnn l n e) = l+ ann (ModuleAnn l e) = l+ amap f (Ann l n e) = Ann (f l) n e+ amap f (TypeAnn l n e) = TypeAnn (f l) n e+ amap f (ModuleAnn l e) = ModuleAnn (f l) e+ +instance Annotated DataOrNew where+ ann (DataType l) = l+ ann (NewType l) = l+ amap = fmap++instance Annotated DeclHead where+ ann (DHead l n tvs) = l+ ann (DHInfix l tva n tvb) = l+ ann (DHParen l dh) = l+ amap f (DHead l n tvs) = DHead (f l) n tvs+ amap f (DHInfix l tva n tvb) = DHInfix (f l) tva n tvb+ amap f (DHParen l dh) = DHParen (f l) dh++instance Annotated InstHead where+ ann (IHead l qn ts) = l+ ann (IHInfix l ta qn tb) = l+ ann (IHParen l ih) = l+ amap f (IHead l qn ts) = IHead (f l) qn ts+ amap f (IHInfix l ta qn tb) = IHInfix (f l) ta qn tb+ amap f (IHParen l ih) = IHParen (f l) ih++instance Annotated Binds where+ ann (BDecls l decls) = l+ ann (IPBinds l ibs) = l+ amap f (BDecls l decls) = BDecls (f l) decls+ amap f (IPBinds l ibs) = IPBinds (f l) ibs++instance Annotated IPBind where+ ann (IPBind l ipn e) = l+ amap f (IPBind l ipn e) = IPBind (f l) ipn e++instance Annotated Match where+ ann (Match l n ps rhs bs) = l+ ann (InfixMatch l a n b rhs bs) = l+ amap f (Match l n ps rhs bs) = Match (f l) n ps rhs bs+ amap f (InfixMatch l a n b rhs bs) = InfixMatch (f l) a n b rhs bs++instance Annotated QualConDecl where+ ann (QualConDecl l tvs cx cd) = l+ amap f (QualConDecl l tvs cx cd) = QualConDecl (f l) tvs cx cd++instance Annotated ConDecl where+ ann (ConDecl l n bts) = l+ ann (InfixConDecl l ta n tb) = l+ ann (RecDecl l n nsbts) = l+ amap f (ConDecl l n bts) = ConDecl (f l) n bts+ amap f (InfixConDecl l ta n tb) = InfixConDecl (f l) ta n tb+ amap f (RecDecl l n fds) = RecDecl (f l) n fds++instance Annotated FieldDecl where+ ann (FieldDecl l ns t) = l+ amap f (FieldDecl l ns t) = FieldDecl (f l) ns t++instance Annotated GadtDecl where+ ann (GadtDecl l n t) = l+ amap f (GadtDecl l n t) = GadtDecl (f l) n t++instance Annotated ClassDecl where+ ann (ClsDecl l d) = l+ ann (ClsDataFam l cx dh mk) = l+ ann (ClsTyFam l dh mk) = l+ ann (ClsTyDef l t1 t2) = l+ amap f (ClsDecl l d) = ClsDecl (f l) d+ amap f (ClsDataFam l mcx dh mk) = ClsDataFam (f l) mcx dh mk+ amap f (ClsTyFam l dh mk) = ClsTyFam (f l) dh mk+ amap f (ClsTyDef l t1 t2) = ClsTyDef (f l) t1 t2++instance Annotated InstDecl where+ ann id = case id of+ InsDecl l d -> l+ InsType l t1 t2 -> l+ InsData l dn t cds ders -> l+ InsGData l dn t mk gds ders -> l+-- InsInline l b act qn -> l+ amap f id = case id of+ InsDecl l d -> InsDecl (f l) d+ InsType l t1 t2 -> InsType (f l) t1 t2+ InsData l dn t cds ders -> InsData (f l) dn t cds ders+ InsGData l dn t mk gds ders -> InsGData (f l) dn t mk gds ders+-- InsInline l b act qn -> InsInline (f l) b act qn++instance Annotated BangType where+ ann (BangedTy l t) = l+ ann (UnBangedTy l t) = l+ ann (UnpackedTy l t) = l+ amap f (BangedTy l t) = BangedTy (f l) t+ amap f (UnBangedTy l t) = UnBangedTy (f l) t+ amap f (UnpackedTy l t) = UnpackedTy (f l) t++instance Annotated Rhs where+ ann (UnGuardedRhs l e) = l+ ann (GuardedRhss l grhss) = l+ amap f (UnGuardedRhs l e) = UnGuardedRhs (f l) e+ amap f (GuardedRhss l grhss) = GuardedRhss (f l) grhss++instance Annotated GuardedRhs where+ ann (GuardedRhs l ss e) = l+ amap f (GuardedRhs l ss e) = GuardedRhs (f l) ss e++instance Annotated Type where+ ann t = case t of+ TyForall l mtvs cx t -> l+ TyFun l t1 t2 -> l+ TyTuple l b ts -> l+ TyList l t -> l+ TyApp l t1 t2 -> l+ TyVar l n -> l+ TyCon l qn -> l+ TyParen l t -> l+ TyInfix l ta qn tb -> l+ TyKind l t k -> l+ amap f t = case t of+ TyForall l mtvs mcx t -> TyForall (f l) mtvs mcx t+ TyFun l t1 t2 -> TyFun (f l) t1 t2+ TyTuple l b ts -> TyTuple (f l) b ts+ TyList l t -> TyList (f l) t+ TyApp l t1 t2 -> TyApp (f l) t1 t2+ TyVar l n -> TyVar (f l) n+ TyCon l qn -> TyCon (f l) qn+ TyParen l t -> TyParen (f l) t+ TyInfix l ta qn tb -> TyInfix (f l) ta qn tb+ TyKind l t k -> TyKind (f l) t k++instance Annotated TyVarBind where+ ann (KindedVar l n k) = l+ ann (UnkindedVar l n) = l+ amap f (KindedVar l n k) = KindedVar (f l) n k+ amap f (UnkindedVar l n) = UnkindedVar (f l) n++instance Annotated Kind where+ ann (KindStar l) = l+ ann (KindBang l) = l+ ann (KindFn l k1 k2) = l+ ann (KindParen l k) = l+ ann (KindVar l v) = l+ amap f (KindStar l) = KindStar (f l)+ amap f (KindBang l) = KindBang (f l)+ amap f (KindFn l k1 k2) = KindFn (f l) k1 k2+ amap f (KindParen l k) = KindParen (f l) k+ amap f (KindVar l n) = KindVar (f l) n++instance Annotated FunDep where+ ann (FunDep l ns1 ns2) = l+ amap f (FunDep l ns1 ns2) = FunDep (f l) ns1 ns2++instance Annotated Context where+ ann (CxSingle l asst ) = l+ ann (CxTuple l assts) = l+ ann (CxParen l ctxt ) = l+ ann (CxEmpty l) = l+ amap f (CxSingle l asst ) = CxSingle (f l) asst+ amap f (CxTuple l assts) = CxTuple (f l) assts+ amap f (CxParen l ctxt ) = CxParen (f l) ctxt+ amap f (CxEmpty l) = CxEmpty (f l)++instance Annotated Asst where+ ann asst = case asst of+ ClassA l qn ts -> l+ InfixA l ta qn tb -> l+ IParam l ipn t -> l+ EqualP l t1 t2 -> l+ amap f asst = case asst of+ ClassA l qn ts -> ClassA (f l) qn ts+ InfixA l ta qn tb -> InfixA (f l) ta qn tb+ IParam l ipn t -> IParam (f l) ipn t+ EqualP l t1 t2 -> EqualP (f l) t1 t2++instance Annotated Literal where+ ann lit = case lit of+ Char l c rw -> l+ String l s rw -> l+ Int l i rw -> l+ Frac l r rw -> l+ PrimInt l i rw -> l+ PrimWord l i rw -> l+ PrimFloat l r rw -> l+ PrimDouble l r rw -> l+ PrimChar l c rw -> l+ PrimString l s rw -> l+ amap = fmap++instance Annotated Exp where+ ann e = case e of+ Var l qn -> l+ IPVar l ipn -> l+ Con l qn -> l+ Lit l lit -> l+ InfixApp l e1 qop e2 -> l+ App l e1 e2 -> l+ NegApp l e -> l+ Lambda l ps e -> l+ Let l bs e -> l+ If l ec et ee -> l+ Case l e alts -> l+ Do l ss -> l+ MDo l ss -> l+ Tuple l es -> l+ TupleSection l mes -> l+ List l es -> l+ FSContext l e -> l+ Paren l e -> l+ LeftSection l e qop -> l+ RightSection l qop e -> l+ RecConstr l qn fups -> l+ RecUpdate l e fups -> l+ EnumFrom l e -> l+ EnumFromTo l ef et -> l+ EnumFromThen l ef et -> l+ EnumFromThenTo l ef eth eto -> l+ ListComp l e qss -> l+ ParComp l e qsss -> l+ ExpTypeSig l e t -> l+ VarQuote l qn -> l+ TypQuote l qn -> l+ BracketExp l br -> l+ SpliceExp l sp -> l+ QuasiQuote l sn se -> l++ XTag l xn xas me es -> l+ XETag l xn xas me -> l+ XPcdata l s -> l+ XExpTag l e -> l+ XChildTag l es -> l++ CorePragma l s e -> l+ SCCPragma l s e -> l+ GenPragma l s n12 n34 e -> l++ Proc l p e -> l+ LeftArrApp l e1 e2 -> l+ RightArrApp l e1 e2 -> l+ LeftArrHighApp l e1 e2 -> l+ RightArrHighApp l e1 e2 -> l++ amap f e = case e of+ Var l qn -> Var (f l) qn+ IPVar l ipn -> IPVar (f l) ipn+ Con l qn -> Con (f l) qn+ Lit l lit -> Lit (f l) lit+ InfixApp l e1 qop e2 -> InfixApp (f l) e1 qop e2+ App l e1 e2 -> App (f l) e1 e2+ NegApp l e -> NegApp (f l) e+ Lambda l ps e -> Lambda (f l) ps e+ Let l bs e -> Let (f l) bs e+ If l ec et ee -> If (f l) ec et ee+ Case l e alts -> Case (f l) e alts+ Do l ss -> Do (f l) ss+ MDo l ss -> MDo (f l) ss+ Tuple l es -> Tuple (f l) es+ TupleSection l mes -> TupleSection (f l) mes+ List l es -> List (f l) es+ FSContext l e -> FSContext (f l) e+ Paren l e -> Paren (f l) e+ LeftSection l e qop -> LeftSection (f l) e qop+ RightSection l qop e -> RightSection (f l) qop e+ RecConstr l qn fups -> RecConstr (f l) qn fups+ RecUpdate l e fups -> RecUpdate (f l) e fups+ EnumFrom l e -> EnumFrom (f l) e+ EnumFromTo l ef et -> EnumFromTo (f l) ef et+ EnumFromThen l ef et -> EnumFromThen (f l) ef et+ EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) ef eth eto+ ListComp l e qss -> ListComp (f l) e qss+ ParComp l e qsss -> ParComp (f l) e qsss+ ExpTypeSig l e t -> ExpTypeSig (f l) e t+ VarQuote l qn -> VarQuote (f l) qn+ TypQuote l qn -> TypQuote (f l) qn+ BracketExp l br -> BracketExp (f l) br+ SpliceExp l sp -> SpliceExp (f l) sp+ QuasiQuote l sn se -> QuasiQuote (f l) sn se++ XTag l xn xas me es -> XTag (f l) xn xas me es+ XETag l xn xas me -> XETag (f l) xn xas me+ XPcdata l s -> XPcdata (f l) s+ XExpTag l e -> XExpTag (f l) e+ XChildTag l es -> XChildTag (f l) es++ CorePragma l s e -> CorePragma (f l) s e+ SCCPragma l s e -> SCCPragma (f l) s e+ GenPragma l s n12 n34 e -> GenPragma (f l) s n12 n34 e++ Proc l p e -> Proc (f l) p e+ LeftArrApp l e1 e2 -> LeftArrApp (f l) e1 e2+ RightArrApp l e1 e2 -> RightArrApp (f l) e1 e2+ LeftArrHighApp l e1 e2 -> LeftArrHighApp (f l) e1 e2+ RightArrHighApp l e1 e2 -> RightArrHighApp (f l) e1 e2+++instance Annotated XName where+ ann (XName l s) = l+ ann (XDomName l sd sn) = l+ amap = fmap++instance Annotated XAttr where+ ann (XAttr l xn e) = l+ amap f (XAttr l xn e) = XAttr (f l) xn e++instance Annotated Bracket where+ ann (ExpBracket l e) = l+ ann (PatBracket l p) = l+ ann (TypeBracket l t) = l+ ann (DeclBracket l ds) = l+ amap f (ExpBracket l e) = ExpBracket (f l) e+ amap f (PatBracket l p) = PatBracket (f l) p+ amap f (TypeBracket l t) = TypeBracket (f l) t+ amap f (DeclBracket l ds) = DeclBracket (f l) ds++instance Annotated Splice where+ ann (IdSplice l s) = l+ ann (ParenSplice l e) = l+ amap f (IdSplice l s) = IdSplice (f l) s+ amap f (ParenSplice l e) = ParenSplice (f l) e++instance Annotated Safety where+ ann (PlayRisky l) = l+ ann (PlaySafe l b) = l+ amap = fmap++instance Annotated CallConv where+ ann (StdCall l) = l+ ann (CCall l) = l+ amap = fmap++instance Annotated ModulePragma where+ ann (LanguagePragma l ns) = l+ ann (OptionsPragma l mt s) = l+ ann (AnnModulePragma l a) = l+ amap f (LanguagePragma l ns) = LanguagePragma (f l) ns+ amap f (AnnModulePragma l a) = AnnModulePragma (f l) a+ amap f p = fmap f p++instance Annotated Activation where+ ann (ActiveFrom l k) = l+ ann (ActiveUntil l k) = l+ amap = fmap++instance Annotated Rule where+ ann (Rule l s act mrvs e1 e2) = l+ amap f (Rule l s act mrvs e1 e2) = Rule (f l) s act mrvs e1 e2++instance Annotated RuleVar where+ ann (RuleVar l n) = l+ ann (TypedRuleVar l n t) = l+ amap f (RuleVar l n) = RuleVar (f l) n+ amap f (TypedRuleVar l n t) = TypedRuleVar (f l) n t++instance Annotated WarningText where+ ann (DeprText l s) = l+ ann (WarnText l s) = l+ amap = fmap++instance Annotated Pat where+ ann p = case p of+ PVar l n -> l+ PLit l lit -> l+ PNeg l p -> l+ PNPlusK l n k -> l+ PInfixApp l pa qn pb -> l+ PApp l qn ps -> l+ PTuple l ps -> l+ PList l ps -> l+ PParen l p -> l+ PRec l qn pfs -> l+ PAsPat l n p -> l+ PWildCard l -> l+ PIrrPat l p -> l+ PatTypeSig l p t -> l+ PViewPat l e p -> l+ PRPat l rps -> l+ PXTag l xn pxas mp ps -> l+ PXETag l xn pxas mp -> l+ PXPcdata l s -> l+ PXPatTag l p -> l+ PXRPats l rps -> l+ PExplTypeArg l qn t -> l+ PQuasiQuote l sn st -> l+ PBangPat l p -> l+ amap f p = case p of+ PVar l n -> PVar (f l) n+ PLit l lit -> PLit (f l) lit+ PNeg l p -> PNeg (f l) p+ PNPlusK l n k -> PNPlusK (f l) n k+ PInfixApp l pa qn pb -> PInfixApp (f l) pa qn pb+ PApp l qn ps -> PApp (f l) qn ps+ PTuple l ps -> PTuple (f l) ps+ PList l ps -> PList (f l) ps+ PParen l p -> PParen (f l) p+ PRec l qn pfs -> PRec (f l) qn pfs+ PAsPat l n p -> PAsPat (f l) n p+ PWildCard l -> PWildCard (f l)+ PIrrPat l p -> PIrrPat (f l) p+ PatTypeSig l p t -> PatTypeSig (f l) p t+ PViewPat l e p -> PViewPat (f l) e p+ PRPat l rps -> PRPat (f l) rps+ PXTag l xn pxas mp ps -> PXTag (f l) xn pxas mp ps+ PXETag l xn pxas mp -> PXETag (f l) xn pxas mp+ PXPcdata l s -> PXPcdata (f l) s+ PXPatTag l p -> PXPatTag (f l) p+ PXRPats l rps -> PXRPats (f l) rps+ PExplTypeArg l qn t -> PExplTypeArg (f l) qn t+ PQuasiQuote l sn st -> PQuasiQuote (f l) sn st+ PBangPat l p -> PBangPat (f l) p++instance Annotated PXAttr where+ ann (PXAttr l xn p) = l+ amap f (PXAttr l xn p) = PXAttr (f l) xn p++instance Annotated RPatOp where+ ann (RPStar l) = l+ ann (RPStarG l) = l+ ann (RPPlus l) = l+ ann (RPPlusG l) = l+ ann (RPOpt l) = l+ ann (RPOptG l) = l+ amap = fmap++instance Annotated RPat where+ ann rp = case rp of+ RPOp l rp rop -> l+ RPEither l rp1 rp2 -> l+ RPSeq l rps -> l+ RPGuard l p ss -> l+ RPCAs l n rp -> l+ RPAs l n rp -> l+ RPParen l rp -> l+ RPPat l p -> l+ amap f rp = case rp of+ RPOp l rp rop -> RPOp (f l) rp rop+ RPEither l rp1 rp2 -> RPEither (f l) rp1 rp2+ RPSeq l rps -> RPSeq (f l) rps+ RPGuard l p ss -> RPGuard (f l) p ss+ RPCAs l n rp -> RPCAs (f l) n rp+ RPAs l n rp -> RPAs (f l) n rp+ RPParen l rp -> RPParen (f l) rp+ RPPat l p -> RPPat (f l) p++instance Annotated PatField where+ ann (PFieldPat l qn p) = l+ ann (PFieldPun l n) = l+ ann (PFieldWildcard l) = l+ amap f (PFieldPat l qn p) = PFieldPat (f l) qn p+ amap f (PFieldPun l n) = PFieldPun (f l) n+ amap f (PFieldWildcard l) = PFieldWildcard (f l)++instance Annotated Stmt where+ ann (Generator l p e) = l+ ann (Qualifier l e) = l+ ann (LetStmt l bs) = l+ ann (RecStmt l ss) = l+ amap f (Generator l p e) = Generator (f l) p e+ amap f (Qualifier l e) = Qualifier (f l) e+ amap f (LetStmt l bs) = LetStmt (f l) bs+ amap f (RecStmt l ss) = RecStmt (f l) ss++instance Annotated QualStmt where+ ann (QualStmt l s) = l+ ann (ThenTrans l e) = l+ ann (ThenBy l e1 e2) = l+ ann (GroupBy l e) = l+ ann (GroupUsing l e) = l+ ann (GroupByUsing l e1 e2) = l+ amap f (QualStmt l s) = QualStmt (f l) s+ amap f (ThenTrans l e) = ThenTrans (f l) e+ amap f (ThenBy l e1 e2) = ThenBy (f l) e1 e2+ amap f (GroupBy l e) = GroupBy (f l) e+ amap f (GroupUsing l e) = GroupUsing (f l) e+ amap f (GroupByUsing l e1 e2) = GroupByUsing (f l) e1 e2++instance Annotated FieldUpdate where+ ann (FieldUpdate l qn e) = l+ ann (FieldPun l n) = l+ ann (FieldWildcard l) = l+ amap f (FieldUpdate l qn e) = FieldUpdate (f l) qn e+ amap f (FieldPun l n) = FieldPun (f l) n+ amap f (FieldWildcard l) = FieldWildcard (f l)++instance Annotated Alt where+ ann (Alt l p gs bs) = l+ amap f (Alt l p gs bs) = Alt (f l) p gs bs++instance Annotated GuardedAlts where+ ann (UnGuardedAlt l e) = l+ ann (GuardedAlts l galts) = l+ amap f (UnGuardedAlt l e) = UnGuardedAlt (f l) e+ amap f (GuardedAlts l galts) = GuardedAlts (f l) galts++instance Annotated GuardedAlt where+ ann (GuardedAlt l ss e) = l+ amap f (GuardedAlt l ss e) = GuardedAlt (f l) ss e
+ HSE/Build.hs view
@@ -0,0 +1,300 @@+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Build+-- Copyright : (c) The GHC Team, 1997-2000,+-- (c) Niklas Broberg 2004+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : experimental+-- Portability : portable+--+-- This module contains combinators to use when building+-- Haskell source trees programmatically, as opposed to+-- parsing them from a string. The contents here are quite+-- experimental and will likely receive a lot of attention+-- when the rest has stabilised.+--+-----------------------------------------------------------------------------++module HSE.Build (++ -- * Syntax building functions+ name, -- :: String -> Name+ sym, -- :: String -> Name+ var, -- :: Name -> Exp+ op, -- :: Name -> QOp+ qvar, -- :: Module -> Name -> Exp+ pvar, -- :: Name -> Pat+ app, -- :: Exp -> Exp -> Exp+ infixApp, -- :: Exp -> QOp -> Exp -> Exp+ appFun, -- :: Exp -> [Exp] -> Exp+ pApp, -- :: Name -> [Pat] -> Pat+ tuple, -- :: [Exp] -> Exp+ pTuple, -- :: [Pat] -> Pat+ varTuple, -- :: [Name] -> Exp+ pvarTuple, -- :: [Name] -> Pat+ function, -- :: String -> Exp+ strE, -- :: String -> Exp+ charE, -- :: Char -> Exp+ intE, -- :: Integer -> Exp+ strP, -- :: String -> Pat+ charP, -- :: Char -> Pat+ intP, -- :: Integer -> Pat+ doE, -- :: [Stmt] -> Exp+ lamE, -- :: SrcLoc -> [Pat] -> Exp -> Exp+ letE, -- :: [Decl] -> Exp -> Exp+ caseE, -- :: Exp -> [Alt] -> Exp+ alt, -- :: SrcLoc -> Pat -> Exp -> Alt+ altGW, -- :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt+ listE, -- :: [Exp] -> Exp+ eList, -- :: Exp+ peList, -- :: Pat+ fscontext, -- :: Exp -> Exp+ paren, -- :: Exp -> Exp+ pParen, -- :: Pat -> Pat+ qualStmt, -- :: Exp -> Stmt+ genStmt, -- :: SrcLoc -> Pat -> Exp -> Stmt+ letStmt, -- :: [Decl] -> Stmt+ binds, -- :: [Decl] -> Binds+ noBinds, -- :: Binds+ freeSectSlot, -- :: Exp+ wildcard, -- :: Pat+ genNames, -- :: String -> Int -> [Name]++ -- * More advanced building+ sfun, -- :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl+ simpleFun, -- :: SrcLoc -> Name -> Name -> Exp -> Decl+ patBind, -- :: SrcLoc -> Pat -> Exp -> Decl+ patBindWhere, -- :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl+ nameBind, -- :: SrcLoc -> Name -> Exp -> Decl+ metaFunction, -- :: String -> [Exp] -> Exp+ metaConPat -- :: String -> [Pat] -> Pat+ ) where++import HSE.Syntax++-----------------------------------------------------------------------------+-- Help functions for Abstract syntax++-- | An identifier with the given string as its name.+-- The string should be a valid Haskell identifier.+name :: String -> Name+name = Ident++-- | A symbol identifier. The string should be a valid+-- Haskell symbol identifier.+sym :: String -> Name+sym = Symbol++-- | A local variable as expression.+var :: Name -> Exp+var = Var . UnQual++-- | Use the given identifier as an operator.+op :: Name -> QOp+op = QVarOp . UnQual++-- | A qualified variable as expression.+qvar :: ModuleName -> Name -> Exp+qvar m n = Var $ Qual m n++-- | A pattern variable.+pvar :: Name -> Pat+pvar = PVar++-- | Application of expressions by juxtaposition.+app :: Exp -> Exp -> Exp+app = App++-- | Apply an operator infix.+infixApp :: Exp -> QOp -> Exp -> Exp+infixApp = InfixApp++-- | Apply a function to a list of arguments.+appFun :: Exp -> [Exp] -> Exp+appFun f [] = f+appFun f (a:as) = appFun (app f a) as++-- | A constructor pattern, with argument patterns.+pApp :: Name -> [Pat] -> Pat+pApp n ps = PApp (UnQual n) ps++-- | A tuple expression.+tuple :: [Exp] -> Exp+tuple = Tuple++-- | A tuple pattern.+pTuple :: [Pat] -> Pat+pTuple = PTuple++-- | A tuple expression consisting of variables only.+varTuple :: [Name] -> Exp+varTuple ns = tuple $ map var ns++-- | A tuple pattern consisting of variables only.+pvarTuple :: [Name] -> Pat+pvarTuple ns = pTuple $ map pvar ns++-- | A function with a given name.+function :: String -> Exp+function = var . Ident++-- | A literal string expression.+strE :: String -> Exp+strE = Lit . String++-- | A literal character expression.+charE :: Char -> Exp+charE = Lit . Char++-- | A literal integer expression.+intE :: Integer -> Exp+intE = Lit . Int++-- | A literal string pattern.+strP :: String -> Pat+strP = PLit . String++-- | A literal character pattern.+charP :: Char -> Pat+charP = PLit . Char++-- | A literal integer pattern.+intP :: Integer -> Pat+intP = PLit . Int++-- | A do block formed by the given statements.+-- The last statement in the list should be+-- a 'Qualifier' expression.+doE :: [Stmt] -> Exp+doE = Do++-- | Lambda abstraction, given a list of argument+-- patterns and an expression body.+lamE :: SrcLoc -> [Pat] -> Exp -> Exp+lamE = Lambda++-- | A @let@ ... @in@ block.+letE :: [Decl] -> Exp -> Exp+letE ds e = Let (binds ds) e++-- | A @case@ expression.+caseE :: Exp -> [Alt] -> Exp+caseE = Case++-- | An unguarded alternative in a @case@ expression.+alt :: SrcLoc -> Pat -> Exp -> Alt+alt s p e = Alt s p (unGAlt e) noBinds++-- | An alternative with a single guard in a @case@ expression.+altGW :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt+altGW s p gs e w = Alt s p (gAlt s gs e) w++-- | An unguarded righthand side of a @case@ alternative.+unGAlt :: Exp -> GuardedAlts+unGAlt = UnGuardedAlt++-- | An list of guarded righthand sides for a @case@ alternative.+gAlts :: SrcLoc -> [([Stmt],Exp)] -> GuardedAlts+gAlts s as = GuardedAlts $ map (\(gs,e) -> GuardedAlt s gs e) as++-- | A single guarded righthand side for a @case@ alternative.+gAlt :: SrcLoc -> [Stmt] -> Exp -> GuardedAlts+gAlt s gs e = gAlts s [(gs,e)]++-- | A list expression.+listE :: [Exp] -> Exp+listE = List++-- | The empty list expression.+eList :: Exp+eList = List []++-- | The empty list pattern.+peList :: Pat+peList = PList []++-- | Put FreeSect context around an expression.+fscontext :: Exp -> Exp+fscontext = FSContext++-- | Put parentheses around an expression.+paren :: Exp -> Exp+paren = Paren++-- | Put parentheses around a pattern.+pParen :: Pat -> Pat+pParen = PParen++-- | A qualifier expression statement.+qualStmt :: Exp -> Stmt+qualStmt = Qualifier++-- | A generator statement: /pat/ @<-@ /exp/+genStmt :: SrcLoc -> Pat -> Exp -> Stmt+genStmt = Generator++-- | A @let@ binding group as a statement.+letStmt :: [Decl] -> Stmt+letStmt ds = LetStmt $ binds ds++-- | Hoist a set of declarations to a binding group.+binds :: [Decl] -> Binds+binds = BDecls++-- | An empty binding group.+noBinds :: Binds+noBinds = binds []++-- | FreeSect placeholder: @__@+freeSectSlot :: Exp+freeSectSlot = FreeSectSlot++-- | The wildcard pattern: @_@+wildcard :: Pat+wildcard = PWildCard++-- | Generate k names by appending numbers 1 through k to a given string.+genNames :: String -> Int -> [Name]+genNames s k = [ Ident $ s ++ show i | i <- [1..k] ]++-------------------------------------------------------------------------------+-- Some more specialised help functions++-- | A function with a single clause+sfun :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl+sfun s f pvs rhs bs = FunBind [Match s f (map pvar pvs) Nothing rhs bs]++-- | A function with a single clause, a single argument, no guards+-- and no where declarations+simpleFun :: SrcLoc -> Name -> Name -> Exp -> Decl+simpleFun s f a e = let rhs = UnGuardedRhs e+ in sfun s f [a] rhs noBinds++-- | A pattern bind where the pattern is a variable, and where+-- there are no guards and no 'where' clause.+patBind :: SrcLoc -> Pat -> Exp -> Decl+patBind s p e = let rhs = UnGuardedRhs e+ in PatBind s p Nothing rhs noBinds++-- | A pattern bind where the pattern is a variable, and where+-- there are no guards, but with a 'where' clause.+patBindWhere :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl+patBindWhere s p e ds = let rhs = UnGuardedRhs e+ in PatBind s p Nothing rhs (binds ds)++-- | Bind an identifier to an expression.+nameBind :: SrcLoc -> Name -> Exp -> Decl+nameBind s n e = patBind s (pvar n) e++-- | Apply function of a given name to a list of arguments.+metaFunction :: String -> [Exp] -> Exp+metaFunction s es = mf s (reverse es)+ where mf s [] = var $ name s+ mf s (e:es) = app (mf s es) e++-- | Apply a constructor of a given name to a list of pattern+-- arguments, forming a constructor pattern.+metaConPat :: String -> [Pat] -> Pat+metaConPat s ps = pApp (name s) ps
+ HSE/Comments.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-} +module HSE.Comments where + +import HSE.SrcLoc + +#ifdef __GLASGOW_HASKELL__ +#ifdef BASE4 +import Data.Data +#else +import Data.Generics (Data(..),Typeable(..)) +#endif +#endif + +-- | A Haskell comment. The 'Bool' is 'True' if the comment is multi-line, i.e. @{- -}@. +data Comment = Comment Bool SrcSpan String +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif
+ HSE/ExtScheme.hs view
@@ -0,0 +1,37 @@+{-# OPTIONS_HADDOCK hide #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.ExtScheme +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : stable +-- Portability : portable +-- +-- Internal scheme for handling extensions in a +-- convenient fashion. +-- +----------------------------------------------------------------------------- +module HSE.ExtScheme where + +import HSE.Extension + +data ExtScheme = Any [Extension] | All [Extension] + deriving (Eq,Show) + +type MExtScheme = Maybe ExtScheme + +class Enabled a where + isEnabled :: a -> [Extension] -> Bool + +instance Enabled Extension where + isEnabled = elem + +instance Enabled ExtScheme where + isEnabled (Any exts) enabled = any (`elem` enabled) exts + isEnabled (All exts) enabled = all (`elem` enabled) exts + +instance Enabled a => Enabled (Maybe a) where + isEnabled Nothing = const True + isEnabled (Just a) = isEnabled a
+ HSE/Extension.hs view
@@ -0,0 +1,249 @@+----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Extension +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : transient +-- Portability : portable +-- +-- This entire module should be replaced with +-- Language.Haskell.Extension from cabal, but we must +-- wait for a release of cabal that includes the +-- 'XmlSyntax' and 'RegularPatterns' extensions. +-- +----------------------------------------------------------------------------- +module HSE.Extension ( + -- * Extensions + Extension(..), classifyExtension, impliesExts, + + -- * Extension groups + glasgowExts, knownExtensions + + ) where + + +-- | This datatype is a copy of the one in Cabal's Language.Haskell.Extension module. +-- The intention is to eventually import it from Cabal, but we need to wait for +-- the next release of Cabal which includes XmlSyntax and RegularPatterns. +data Extension + = OverlappingInstances + | UndecidableInstances + | IncoherentInstances + | RecursiveDo + | ParallelListComp + | MultiParamTypeClasses + | NoMonomorphismRestriction + | FunctionalDependencies + | ExplicitForall + | Rank2Types + | RankNTypes + | PolymorphicComponents + | ExistentialQuantification + | ScopedTypeVariables + | ImplicitParams + | FlexibleContexts + | FlexibleInstances + | EmptyDataDecls + | CPP + + | KindSignatures + | BangPatterns + | TypeSynonymInstances + | TemplateHaskell + | ForeignFunctionInterface + | Arrows + | Generics + | NoImplicitPrelude + | NamedFieldPuns + | PatternGuards + | GeneralizedNewtypeDeriving + + | ExtensibleRecords + | RestrictedTypeSynonyms + | HereDocuments + | MagicHash + | TypeFamilies + | StandaloneDeriving + + | UnicodeSyntax + | PatternSignatures + | UnliftedFFITypes + | LiberalTypeSynonyms + | TypeOperators + | RecordWildCards + | RecordPuns -- should be deprecated + | DisambiguateRecordFields + | OverloadedStrings + | GADTs + | MonoPatBinds + | NoMonoPatBinds -- should be deprecated + | RelaxedPolyRec + | ExtendedDefaultRules + | UnboxedTuples + | DeriveDataTypeable + | ConstrainedClassMethods + + | PackageImports + + | ImpredicativeTypes + | NewQualifiedOperators + | PostfixOperators + | QuasiQuotes + | TransformListComp + | ViewPatterns + + | XmlSyntax + + | RegularPatterns + + | TupleSections + + | FreeSections + + | UnknownExtension String + deriving (Eq, Ord, Show, Read) + + +-- | Certain extensions imply other extensions, and this function +-- makes the implication explicit. This also handles deprecated +-- extensions, which imply their replacements. +-- The returned valued is the transitive closure of implied +-- extensions. +impliesExts :: [Extension] -> [Extension] +impliesExts = go + where go [] = [] + go es = let xs = concatMap implE es + ys = filter (not . flip elem es) xs + in es ++ go ys + + implE e = case e of + TypeFamilies -> [KindSignatures] + ScopedTypeVariables -> [TypeOperators, ExplicitForall] + XmlSyntax -> [RegularPatterns] + RegularPatterns -> [PatternGuards] + RankNTypes -> [Rank2Types] + Rank2Types -> [PolymorphicComponents] + PolymorphicComponents -> [ExplicitForall] + LiberalTypeSynonyms -> [ExplicitForall] + -- Deprecations + RecordPuns -> [NamedFieldPuns] + PatternSignatures -> [ScopedTypeVariables] + e -> [] + +-- | The list of extensions enabled by +-- GHC's portmanteau -fglasgow-exts flag. +glasgowExts :: [Extension] +glasgowExts = [ + ForeignFunctionInterface + , UnliftedFFITypes + , GADTs + , ImplicitParams + , ScopedTypeVariables + , UnboxedTuples + , TypeSynonymInstances + , StandaloneDeriving + , DeriveDataTypeable + , FlexibleContexts + , FlexibleInstances + , ConstrainedClassMethods + , MultiParamTypeClasses + , FunctionalDependencies + , MagicHash + , PolymorphicComponents + , ExistentialQuantification + , UnicodeSyntax + , PostfixOperators + , PatternGuards + , LiberalTypeSynonyms + , RankNTypes + , ImpredicativeTypes + , TypeOperators + , RecursiveDo + , ParallelListComp + , EmptyDataDecls + , KindSignatures + , GeneralizedNewtypeDeriving + , TypeFamilies + ] + +-- | List of all known extensions. Poor man's 'Enum' instance +-- (we can't enum with the 'UnknownExtension' constructor). +knownExtensions :: [Extension] +knownExtensions = + [ OverlappingInstances + , UndecidableInstances + , IncoherentInstances + , RecursiveDo + , ParallelListComp + , MultiParamTypeClasses + , NoMonomorphismRestriction + , FunctionalDependencies + , ExplicitForall + , Rank2Types + , RankNTypes + , PolymorphicComponents + , ExistentialQuantification + , ScopedTypeVariables + , ImplicitParams + , FlexibleContexts + , FlexibleInstances + , EmptyDataDecls + , CPP + , KindSignatures + , BangPatterns + , TypeSynonymInstances + , TemplateHaskell + , ForeignFunctionInterface + , Arrows + , Generics + , NoImplicitPrelude + , NamedFieldPuns + , PatternGuards + , GeneralizedNewtypeDeriving + , ExtensibleRecords + , RestrictedTypeSynonyms + , HereDocuments + , MagicHash + , TypeFamilies + , StandaloneDeriving + , UnicodeSyntax + , PatternSignatures + , UnliftedFFITypes + , LiberalTypeSynonyms + , TypeOperators + , RecordWildCards + , RecordPuns -- should be deprecated + , DisambiguateRecordFields + , OverloadedStrings + , GADTs + , MonoPatBinds + , NoMonoPatBinds -- should be deprecated + , RelaxedPolyRec + , ExtendedDefaultRules + , UnboxedTuples + , DeriveDataTypeable + , ConstrainedClassMethods + , PackageImports + , ImpredicativeTypes + , NewQualifiedOperators + , PostfixOperators + , QuasiQuotes + , TransformListComp + , ViewPatterns + , XmlSyntax + , RegularPatterns + , TupleSections + , FreeSections + ] + + + +-- | A clever version of read that returns an 'UnknownExtension' +-- if the string is not recognised. +classifyExtension :: String -> Extension +classifyExtension str + = case readsPrec 0 str of + [(e,"")] -> e + _ -> UnknownExtension str
+ HSE/Fixity.hs view
@@ -0,0 +1,399 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Fixity +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : stable +-- Portability : portable +-- +-- Fixity information to give the parser so that infix operators can +-- be parsed properly. +-- +----------------------------------------------------------------------------- +module HSE.Fixity + ( + -- * Fixity representation + Fixity(..) + -- | The following three functions all create lists of + -- fixities from textual representations of operators. + -- The intended usage is e.g. + -- + -- > fixs = infixr_ 0 ["$","$!","`seq`"] + -- + -- Note that the operators are expected as you would + -- write them infix, i.e. with ` characters surrounding + -- /varid/ operators, and /varsym/ operators written as is. + , infix_, infixl_, infixr_ + -- ** Collections of fixities + , preludeFixities, baseFixities + + -- * Applying fixities to an AST + , AppFixity(..) + ) where + +import HSE.Syntax + +import Data.Char (isUpper) +import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4) +import Data.Traversable (mapM) +import Prelude hiding (mapM) + +#ifdef __GLASGOW_HASKELL__ +#ifdef BASE4 +import Data.Data hiding (Fixity) +#else +import Data.Generics (Data(..),Typeable(..)) +#endif +#endif + +-- | Operator fixities are represented by their associativity +-- (left, right or none) and their precedence (0-9). +data Fixity = Fixity Assoc Int QName +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + +-- | All AST elements that may include expressions which in turn may +-- need fixity tweaking will be instances of this class. +class AppFixity ast where + -- | Tweak any expressions in the element to account for the + -- fixities given. Assumes that all operator expressions are + -- fully left associative chains to begin with. + applyFixities :: Monad m => [Fixity] -- ^ The fixities to account for. + -> ast -- ^ The element to tweak. + -> m ast -- ^ The same element, but with operator expressions updated, or a failure. + + +instance AppFixity Exp where + applyFixities fixs = infFix fixs <=< leafFix fixs + where -- This is the real meat case. We can assume a left-associative list to begin with. + infFix fixs (InfixApp a op2 z) = do + e <- infFix fixs a + case e of + InfixApp x op1 y -> do + let (a1,p1) = askFixity fixs op1 + (a2,p2) = askFixity fixs op2 + when (p1 == p2 && (a1 /= a2 || a1 == AssocNone)) -- Ambiguous infix expression! + $ fail "Ambiguous infix expression" + if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order + then return $ InfixApp e op2 z + else liftM (InfixApp x op1) (infFix fixs $ InfixApp y op2 z) + _ -> return $ InfixApp e op2 z + + infFix _ e = return e + +instance AppFixity Pat where + applyFixities fixs = infFix fixs <=< leafFixP fixs + where -- Same for patterns + infFix fixs (PInfixApp a op2 z) = do + p <- infFix fixs a + case p of + PInfixApp x op1 y -> do + let (a1,p1) = askFixityP fixs op1 + (a2,p2) = askFixityP fixs op2 + when (p1 == p2 && (a1 /= a2 || a1 == AssocNone)) -- Ambiguous infix expression! + $ fail "Ambiguous infix expression" + if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order + then return $ PInfixApp p op2 z + else liftM (PInfixApp x op1) (infFix fixs $ PInfixApp y op2 z) + _ -> return $ PInfixApp p op2 z + + infFix _ p = return p + + +-- Internal: lookup associativity and precedence of an operator +askFixity :: [Fixity] -> QOp -> (Assoc, Int) +askFixity xs k = askFix xs (f k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp + where + f (QVarOp x) = g x + f (QConOp x) = g x + + g (Special Cons) = UnQual (Symbol ":") + g x = x + +-- Same using patterns +askFixityP :: [Fixity] -> QName -> (Assoc, Int) +askFixityP xs qn = askFix xs (g qn) + where + g (Special Cons) = UnQual (Symbol ":") + g x = x + +askFix :: [Fixity] -> QName -> (Assoc, Int) +askFix xs = \k -> lookupWithDefault (AssocLeft, 9) k mp + where + lookupWithDefault def k mp = case lookup k mp of + Nothing -> def + Just x -> x + + mp = [(x,(a,p)) | Fixity a p x <- xs] + + +-- | All fixities defined in the Prelude. +preludeFixities :: [Fixity] +preludeFixities = concat + [infixr_ 9 ["."] + ,infixl_ 9 ["!!"] + ,infixr_ 8 ["^","^^","**"] + ,infixl_ 7 ["*","/","`quot`","`rem`","`div`","`mod`",":%","%"] + ,infixl_ 6 ["+","-"] + ,infixr_ 5 [":","++"] + ,infix_ 4 ["==","/=","<","<=",">=",">","`elem`","`notElem`"] + ,infixr_ 3 ["&&"] + ,infixr_ 2 ["||"] + ,infixl_ 1 [">>",">>="] + ,infixr_ 1 ["=<<"] + ,infixr_ 0 ["$","$!","`seq`"] + ] + +-- | All fixities defined in the base package. +-- +-- Note that the @+++@ operator appears in both Control.Arrows and +-- Text.ParserCombinators.ReadP. The listed precedence for @+++@ in +-- this list is that of Control.Arrows. +baseFixities :: [Fixity] +baseFixities = preludeFixities ++ concat + [infixl_ 9 ["!","//","!:"] + ,infixl_ 8 ["`shift`","`rotate`","`shiftL`","`shiftR`","`rotateL`","`rotateR`"] + ,infixl_ 7 [".&."] + ,infixl_ 6 ["`xor`"] + ,infix_ 6 [":+"] + ,infixl_ 5 [".|."] + ,infixr_ 5 ["+:+","<++","<+>"] -- fixity conflict for +++ between ReadP and Arrow + ,infix_ 5 ["\\\\"] + ,infixl_ 4 ["<$>","<$","<*>","<*","*>","<**>"] + ,infix_ 4 ["`elemP`","`notElemP`"] + ,infixl_ 3 ["<|>"] + ,infixr_ 3 ["&&&","***"] + ,infixr_ 2 ["+++","|||"] + ,infixr_ 1 ["<=<",">=>",">>>","<<<","^<<","<<^","^>>",">>^"] + ,infixl_ 0 ["`on`"] + ,infixr_ 0 ["`par`","`pseq`"] + ] + +infixr_, infixl_, infix_ :: Int -> [String] -> [Fixity] +infixr_ = fixity AssocRight +infixl_ = fixity AssocLeft +infix_ = fixity AssocNone + +-- Internal: help function for the above definitions. +fixity :: Assoc -> Int -> [String] -> [Fixity] +fixity a p = map (Fixity a p . op) + where + op ('`':xs) = UnQual $ Ident $ init xs + op xs = UnQual $ Symbol xs + + + + + + +------------------------------------------------------------------- +-- Boilerplate - yuck!! Everything below here is internal stuff + +instance AppFixity Module where + applyFixities fixs (Module loc n prs mwt ext imp decls) = + liftM (Module loc n prs mwt ext imp) $ appFixDecls fixs decls + +instance AppFixity Decl where + applyFixities fixs decl = case decl of + ClassDecl loc ctxt n vars deps cdecls -> liftM (ClassDecl loc ctxt n vars deps) $ mapM fix cdecls + InstDecl loc ctxt n ts idecls -> liftM (InstDecl loc ctxt n ts) $ mapM fix idecls + SpliceDecl loc spl -> liftM (SpliceDecl loc) $ fix spl + FunBind matches -> liftM FunBind $ mapM fix matches + PatBind loc p mt rhs bs -> liftM3 (flip (PatBind loc) mt) (fix p) (fix rhs) (fix bs) + AnnPragma loc ann -> liftM (AnnPragma loc) $ fix ann + _ -> return decl + where fix x = applyFixities fixs x + +appFixDecls :: Monad m => [Fixity] -> [Decl] -> m [Decl] +appFixDecls fixs decls = + let extraFixs = getFixities decls + in mapM (applyFixities (fixs++extraFixs)) decls + where getFixities = concatMap getFixity + getFixity (InfixDecl _ a p ops) = map (Fixity a p . g) ops + getFixity _ = [] + g (VarOp x) = UnQual x + g (ConOp x) = UnQual x + +instance AppFixity Annotation where + applyFixities fixs ann = case ann of + Ann n e -> liftM (Ann n) $ fix e + TypeAnn n e -> liftM (TypeAnn n) $ fix e + ModuleAnn e -> liftM ModuleAnn $ fix e + where fix x = applyFixities fixs x + +instance AppFixity ClassDecl where + applyFixities fixs (ClsDecl decl) = liftM ClsDecl $ applyFixities fixs decl + applyFixities _ cdecl = return cdecl + +instance AppFixity InstDecl where + applyFixities fixs (InsDecl decl) = liftM InsDecl $ applyFixities fixs decl + applyFixities _ idecl = return idecl + +instance AppFixity Match where + applyFixities fixs (Match loc n ps mt rhs bs) = liftM3 (flip (Match loc n) mt) (mapM fix ps) (fix rhs) (fix bs) + where fix x = applyFixities fixs x + +instance AppFixity Rhs where + applyFixities fixs rhs = case rhs of + UnGuardedRhs e -> liftM UnGuardedRhs $ fix e + GuardedRhss grhss -> liftM GuardedRhss $ mapM fix grhss + where fix x = applyFixities fixs x + +instance AppFixity GuardedRhs where + applyFixities fixs (GuardedRhs loc stmts e) = liftM2 (GuardedRhs loc) (mapM fix stmts) $ fix e + where fix x = applyFixities fixs x + +instance AppFixity PatField where + applyFixities fixs (PFieldPat n p) = liftM (PFieldPat n) $ applyFixities fixs p + applyFixities _ pf = return pf + +instance AppFixity RPat where + applyFixities fixs rp = case rp of + RPOp rp op -> liftM (flip RPOp op) (fix rp) + RPEither a b -> liftM2 RPEither (fix a) (fix b) + RPSeq rps -> liftM RPSeq $ mapM fix rps + RPGuard p stmts -> liftM2 RPGuard (fix p) $ mapM fix stmts + RPCAs n rp -> liftM (RPCAs n) $ fix rp + RPAs n rp -> liftM (RPAs n) $ fix rp + RPParen rp -> liftM RPParen $ fix rp + RPPat p -> liftM RPPat $ fix p + where fix x = applyFixities fixs x + +instance AppFixity PXAttr where + applyFixities fixs (PXAttr n p) = liftM (PXAttr n) $ applyFixities fixs p + +instance AppFixity Stmt where + applyFixities fixs stmt = case stmt of + Generator loc p e -> liftM2 (Generator loc) (fix p) (fix e) + Qualifier e -> liftM Qualifier $ fix e + LetStmt bs -> liftM LetStmt $ fix bs -- special behavior + RecStmt stmts -> liftM RecStmt $ mapM fix stmts + where fix x = applyFixities fixs x + +instance AppFixity Binds where + applyFixities fixs bs = case bs of + BDecls decls -> liftM BDecls $ appFixDecls fixs decls -- special behavior + IPBinds ips -> liftM IPBinds $ mapM fix ips + where fix x = applyFixities fixs x + + +instance AppFixity IPBind where + applyFixities fixs (IPBind loc n e) = liftM (IPBind loc n) $ applyFixities fixs e + +instance AppFixity FieldUpdate where + applyFixities fixs (FieldUpdate n e) = liftM (FieldUpdate n) $ applyFixities fixs e + applyFixities _ fup = return fup + +instance AppFixity Alt where + applyFixities fixs (Alt loc p galts bs) = liftM3 (Alt loc) (fix p) (fix galts) (fix bs) + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlts where + applyFixities fixs galts = case galts of + UnGuardedAlt e -> liftM UnGuardedAlt $ fix e + GuardedAlts galts -> liftM GuardedAlts $ mapM fix galts + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlt where + applyFixities fixs (GuardedAlt loc stmts e) = liftM2 (GuardedAlt loc) (mapM fix stmts) (fix e) + where fix x = applyFixities fixs x + +instance AppFixity QualStmt where + applyFixities fixs qstmt = case qstmt of + QualStmt s -> liftM QualStmt $ fix s + ThenTrans e -> liftM ThenTrans $ fix e + ThenBy e1 e2 -> liftM2 ThenBy (fix e1) (fix e2) + GroupBy e -> liftM GroupBy (fix e) + GroupUsing e -> liftM GroupUsing (fix e) + GroupByUsing e1 e2 -> liftM2 GroupByUsing (fix e1) (fix e2) + where fix x = applyFixities fixs x + +instance AppFixity Bracket where + applyFixities fixs br = case br of + ExpBracket e -> liftM ExpBracket $ fix e + PatBracket p -> liftM PatBracket $ fix p + DeclBracket ds -> liftM DeclBracket $ mapM fix ds + _ -> return br + where fix x = applyFixities fixs x + +instance AppFixity Splice where + applyFixities fixs (ParenSplice e) = liftM ParenSplice $ applyFixities fixs e + applyFixities _ s = return s + +instance AppFixity XAttr where + applyFixities fixs (XAttr n e) = liftM (XAttr n) $ applyFixities fixs e + + +-- the boring boilerplate stuff for expressions too +-- Recursively fixes the "leaves" of the infix chains, +-- without yet touching the chain itself. We assume all chains are +-- left-associate to begin with. +leafFix fixs e = case e of + InfixApp e1 op e2 -> liftM2 (flip InfixApp op) (leafFix fixs e1) (fix e2) + App e1 e2 -> liftM2 App (fix e1) (fix e2) + NegApp e -> liftM NegApp $ fix e + Lambda loc pats e -> liftM2 (Lambda loc) (mapM fix pats) $ fix e + Let bs e -> liftM2 Let (fix bs) $ fix e + If e a b -> liftM3 If (fix e) (fix a) (fix b) + Case e alts -> liftM2 Case (fix e) $ mapM fix alts + Do stmts -> liftM Do $ mapM fix stmts + MDo stmts -> liftM MDo $ mapM fix stmts + Tuple exps -> liftM Tuple $ mapM fix exps + List exps -> liftM List $ mapM fix exps + FSContext e -> liftM FSContext $ fix e + Paren e -> liftM Paren $ fix e + LeftSection e op -> liftM (flip LeftSection op) (fix e) + RightSection op e -> liftM (RightSection op) $ fix e + RecConstr n fups -> liftM (RecConstr n) $ mapM fix fups + RecUpdate e fups -> liftM2 RecUpdate (fix e) $ mapM fix fups + EnumFrom e -> liftM EnumFrom $ fix e + EnumFromTo e1 e2 -> liftM2 EnumFromTo (fix e1) (fix e2) + EnumFromThen e1 e2 -> liftM2 EnumFromThen (fix e1) (fix e2) + EnumFromThenTo e1 e2 e3 -> liftM3 EnumFromThenTo (fix e1) (fix e2) (fix e3) + ListComp e quals -> liftM2 ListComp (fix e) $ mapM fix quals + ParComp e qualss -> liftM2 ParComp (fix e) $ mapM (mapM fix) qualss + ExpTypeSig loc e t -> liftM (flip (ExpTypeSig loc) t) (fix e) + BracketExp b -> liftM BracketExp $ fix b + SpliceExp s -> liftM SpliceExp $ fix s + XTag loc n ats mexp cs -> liftM3 (XTag loc n) (mapM fix ats) (mapM fix mexp) (mapM fix cs) + XETag loc n ats mexp -> liftM2 (XETag loc n) (mapM fix ats) (mapM fix mexp) + XExpTag e -> liftM XExpTag $ fix e + XChildTag loc cs -> liftM (XChildTag loc) $ mapM fix cs + Proc loc p e -> liftM2 (Proc loc) (fix p) (fix e) + LeftArrApp e1 e2 -> liftM2 LeftArrApp (fix e1) (fix e2) + RightArrApp e1 e2 -> liftM2 RightArrApp (fix e1) (fix e2) + LeftArrHighApp e1 e2 -> liftM2 LeftArrHighApp (fix e1) (fix e2) + RightArrHighApp e1 e2 -> liftM2 RightArrHighApp (fix e1) (fix e2) + CorePragma s e -> liftM (CorePragma s) (fix e) + SCCPragma s e -> liftM (SCCPragma s) (fix e) + GenPragma s ab cd e -> liftM (GenPragma s ab cd) (fix e) + + _ -> return e + where + fix x = applyFixities fixs x + +leafFixP fixs p = case p of + PNeg p -> liftM PNeg $ fix p + PApp n ps -> liftM (PApp n) $ mapM fix ps + PTuple ps -> liftM PTuple $ mapM fix ps + PList ps -> liftM PList $ mapM fix ps + PParen p -> liftM PParen $ fix p + PRec n pfs -> liftM (PRec n) $ mapM fix pfs + PAsPat n p -> liftM (PAsPat n) $ fix p + PIrrPat p -> liftM PIrrPat $ fix p + PatTypeSig loc p t -> liftM (flip (PatTypeSig loc) t) (fix p) + PViewPat e p -> liftM2 PViewPat (fix e) (fix p) + PRPat rps -> liftM PRPat $ mapM fix rps + PXTag loc n ats mp ps -> liftM3 (PXTag loc n) (mapM fix ats) (mapM fix mp) (mapM fix ps) + PXETag loc n ats mp -> liftM2 (PXETag loc n) (mapM fix ats) (mapM fix mp) + PXPatTag p -> liftM PXPatTag $ fix p + PXRPats rps -> liftM PXRPats $ mapM fix rps + PBangPat p -> liftM PBangPat $ fix p + _ -> return p + where fix x = applyFixities fixs x
+ HSE/InternalParser.hs view
@@ -0,0 +1,8103 @@+{-# OPTIONS_GHC -w #-}+{-# OPTIONS -fglasgow-exts -cpp #-}+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module : HSE.Annotated.Parser+-- Copyright : (c) Niklas Broberg 2004-2009,+-- Original (c) Simon Marlow, Sven Panne 1997-2000+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+--+-----------------------------------------------------------------------------+module HSE.InternalParser (+ -- * General parsing+ ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,+ -- * Parsing of specific AST elements+ -- ** Modules+ parseModule, parseModuleWithMode, parseModuleWithComments,+ -- ** Expressions+ parseExp, parseExpWithMode, parseExpWithComments,+ -- ** Statements+ parseStmt, parseStmtWithMode, parseStmtWithComments,+ -- ** Patterns+ parsePat, parsePatWithMode, parsePatWithComments,+ -- ** Declarations+ parseDecl, parseDeclWithMode, parseDeclWithComments,+ -- ** Types+ parseType, parseTypeWithMode, parseTypeWithComments,+ -- ** Multiple modules in one file+ parseModules, parseModulesWithMode, parseModulesWithComments,+ -- ** Option pragmas+ getTopPragmas+ ) where+import HSE.Annotated.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) )+import HSE.Annotated.Syntax ( Type, Exp, Asst )+import HSE.ParseMonad+import HSE.Lexer+import HSE.ParseUtils+import HSE.Annotated.Fixity+import HSE.SrcLoc+import HSE.Comments ( Comment )+import HSE.Extension++import Control.Monad ( liftM, (<=<) )+import qualified Data.Array as Happy_Data_Array+import qualified GHC.Exts as Happy_GHC_Exts++-- parser produced by Happy Version 1.18.6++newtype HappyAbsSyn = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn11 :: ([Module L]) -> (HappyAbsSyn )+happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn11 #-}+happyOut11 :: (HappyAbsSyn ) -> ([Module L])+happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut11 #-}+happyIn12 :: ([[ModulePragma L] -> [S] -> L -> Module L]) -> (HappyAbsSyn )+happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn12 #-}+happyOut12 :: (HappyAbsSyn ) -> ([[ModulePragma L] -> [S] -> L -> Module L])+happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut12 #-}+happyIn13 :: (Module L) -> (HappyAbsSyn )+happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn13 #-}+happyOut13 :: (HappyAbsSyn ) -> (Module L)+happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut13 #-}+happyIn14 :: (PExp L) -> (HappyAbsSyn )+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn ) -> (PExp L)+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: (([ModulePragma L],[S],L)) -> (HappyAbsSyn )+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],L))+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: (([ModulePragma L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],Maybe L))+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: (ModulePragma L) -> (HappyAbsSyn )+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> (ModulePragma L)+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (([Name L],[S])) -> (HappyAbsSyn )+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> (([Name L],[S]))+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: ([ModulePragma L] -> [S] -> L -> Module L) -> (HappyAbsSyn )+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> ([ModulePragma L] -> [S] -> L -> Module L)+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: (Maybe (ModuleHead L)) -> (HappyAbsSyn )+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> (Maybe (ModuleHead L))+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: (Maybe (WarningText L)) -> (HappyAbsSyn )+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> (Maybe (WarningText L))+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (([ImportDecl L],[Decl L],[S],L)) -> (HappyAbsSyn )+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S],L))+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (([ImportDecl L],[Decl L],[S])) -> (HappyAbsSyn )+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S]))+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: ([S]) -> (HappyAbsSyn )+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> ([S])+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: ([S]) -> (HappyAbsSyn )+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> ([S])+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (Maybe (ExportSpecList L)) -> (HappyAbsSyn )+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> (Maybe (ExportSpecList L))+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: (ExportSpecList L) -> (HappyAbsSyn )+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> (ExportSpecList L)+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyIn28 :: ([S]) -> (HappyAbsSyn )+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn ) -> ([S])+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+happyIn29 :: (([ExportSpec L],[S])) -> (HappyAbsSyn )+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn ) -> (([ExportSpec L],[S]))+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+happyIn30 :: (ExportSpec L) -> (HappyAbsSyn )+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn ) -> (ExportSpec L)+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+happyIn31 :: (([ImportDecl L],[S])) -> (HappyAbsSyn )+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn ) -> (([ImportDecl L],[S]))+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+happyIn32 :: (ImportDecl L) -> (HappyAbsSyn )+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn ) -> (ImportDecl L)+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+happyIn33 :: ((Bool,[S])) -> (HappyAbsSyn )+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn ) -> ((Bool,[S]))+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+happyIn34 :: ((Bool,[S])) -> (HappyAbsSyn )+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn ) -> ((Bool,[S]))+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+happyIn35 :: ((Maybe String,[S])) -> (HappyAbsSyn )+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn ) -> ((Maybe String,[S]))+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+happyIn36 :: ((Maybe (ModuleName L),[S],Maybe L)) -> (HappyAbsSyn )+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn ) -> ((Maybe (ModuleName L),[S],Maybe L))+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+happyIn37 :: (Maybe (ImportSpecList L)) -> (HappyAbsSyn )+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn ) -> (Maybe (ImportSpecList L))+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+happyIn38 :: (ImportSpecList L) -> (HappyAbsSyn )+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn ) -> (ImportSpecList L)+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+happyIn39 :: ((Bool, Maybe L,[S])) -> (HappyAbsSyn )+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn ) -> ((Bool, Maybe L,[S]))+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+happyIn40 :: (([ImportSpec L],[S])) -> (HappyAbsSyn )+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn ) -> (([ImportSpec L],[S]))+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+happyIn41 :: (ImportSpec L) -> (HappyAbsSyn )+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn ) -> (ImportSpec L)+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+happyIn42 :: (([CName L],[S])) -> (HappyAbsSyn )+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn ) -> (([CName L],[S]))+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+happyIn43 :: (CName L) -> (HappyAbsSyn )+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn ) -> (CName L)+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+happyIn44 :: (Decl L) -> (HappyAbsSyn )+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn ) -> (Decl L)+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+happyIn45 :: ((Maybe Int, [S])) -> (HappyAbsSyn )+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn ) -> ((Maybe Int, [S]))+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+happyIn46 :: (Assoc L) -> (HappyAbsSyn )+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn ) -> (Assoc L)+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+happyIn47 :: (([Op L],[S],L)) -> (HappyAbsSyn )+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn ) -> (([Op L],[S],L))+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+happyIn48 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+happyIn49 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+happyIn50 :: (Decl L) -> (HappyAbsSyn )+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn ) -> (Decl L)+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+happyIn51 :: (DataOrNew L) -> (HappyAbsSyn )+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn ) -> (DataOrNew L)+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+happyIn52 :: (([Type L],[S])) -> (HappyAbsSyn )+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn ) -> (([Type L],[S]))+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+happyIn53 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+happyIn54 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+happyIn55 :: (Decl L) -> (HappyAbsSyn )+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn ) -> (Decl L)+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+happyIn56 :: (Binds L) -> (HappyAbsSyn )+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn ) -> (Binds L)+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+happyIn57 :: (Decl L) -> (HappyAbsSyn )+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn ) -> (Decl L)+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+happyIn58 :: (Decl L) -> (HappyAbsSyn )+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn ) -> (Decl L)+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+happyIn59 :: (([Type L],[S])) -> (HappyAbsSyn )+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn ) -> (([Type L],[S]))+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+happyIn60 :: (Type L) -> (HappyAbsSyn )+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn ) -> (Type L)+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+happyIn61 :: (Binds L) -> (HappyAbsSyn )+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn ) -> (Binds L)+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+happyIn62 :: (([Name L],[S],L)) -> (HappyAbsSyn )+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn ) -> (([Name L],[S],L))+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+happyIn63 :: (CallConv L) -> (HappyAbsSyn )+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn ) -> (CallConv L)+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+happyIn64 :: (Maybe (Safety L)) -> (HappyAbsSyn )+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn ) -> (Maybe (Safety L))+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+happyIn65 :: ((Maybe String, Name L, Type L, [S])) -> (HappyAbsSyn )+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn ) -> ((Maybe String, Name L, Type L, [S]))+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+happyIn66 :: ([Rule L]) -> (HappyAbsSyn )+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn ) -> ([Rule L])+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+happyIn67 :: (Rule L) -> (HappyAbsSyn )+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn ) -> (Rule L)+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+happyIn68 :: (Maybe (Activation L)) -> (HappyAbsSyn )+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn ) -> (Maybe (Activation L))+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+happyIn69 :: ((Maybe [RuleVar L],[S])) -> (HappyAbsSyn )+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn ) -> ((Maybe [RuleVar L],[S]))+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+happyIn70 :: ([RuleVar L]) -> (HappyAbsSyn )+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn ) -> ([RuleVar L])+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+happyIn71 :: (RuleVar L) -> (HappyAbsSyn )+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn ) -> (RuleVar L)+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+happyIn72 :: (([([Name L],String)],[S])) -> (HappyAbsSyn )+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn ) -> (([([Name L],String)],[S]))+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+happyIn73 :: ((([Name L], String),[S])) -> (HappyAbsSyn )+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn ) -> ((([Name L], String),[S]))+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+happyIn74 :: (([Name L],[S])) -> (HappyAbsSyn )+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn ) -> (([Name L],[S]))+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+happyIn75 :: (Name L) -> (HappyAbsSyn )+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn ) -> (Name L)+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+happyIn76 :: (Annotation L) -> (HappyAbsSyn )+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn ) -> (Annotation L)+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+happyIn77 :: (Type L) -> (HappyAbsSyn )+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn ) -> (Type L)+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+happyIn78 :: (PType L) -> (HappyAbsSyn )+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn ) -> (PType L)+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+happyIn79 :: (Type L) -> (HappyAbsSyn )+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn ) -> (Type L)+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+happyIn80 :: (PType L) -> (HappyAbsSyn )+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn ) -> (PType L)+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+happyIn81 :: (Type L) -> (HappyAbsSyn )+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn ) -> (Type L)+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+happyIn82 :: (PType L) -> (HappyAbsSyn )+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn ) -> (PType L)+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+happyIn83 :: (Type L) -> (HappyAbsSyn )+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn ) -> (Type L)+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+happyIn84 :: (PType L) -> (HappyAbsSyn )+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn ) -> (PType L)+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+happyIn85 :: (QName L) -> (HappyAbsSyn )+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn ) -> (QName L)+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+happyIn86 :: (QName L) -> (HappyAbsSyn )+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn ) -> (QName L)+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+happyIn87 :: (QName L) -> (HappyAbsSyn )+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn ) -> (QName L)+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+happyIn88 :: (Type L) -> (HappyAbsSyn )+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn ) -> (Type L)+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+happyIn89 :: (PType L) -> (HappyAbsSyn )+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn ) -> (PType L)+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+happyIn90 :: (PContext L) -> (HappyAbsSyn )+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn ) -> (PContext L)+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+happyIn91 :: (([PType L],[S])) -> (HappyAbsSyn )+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn ) -> (([PType L],[S]))+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+happyIn92 :: (([PType L],[S])) -> (HappyAbsSyn )+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn ) -> (([PType L],[S]))+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+happyIn93 :: (([TyVarBind L],Maybe L)) -> (HappyAbsSyn )+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn ) -> (([TyVarBind L],Maybe L))+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+happyIn94 :: (TyVarBind L) -> (HappyAbsSyn )+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn ) -> (TyVarBind L)+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+happyIn95 :: (([Name L],Maybe L)) -> (HappyAbsSyn )+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn ) -> (([Name L],Maybe L))+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+happyIn96 :: (([Name L],L)) -> (HappyAbsSyn )+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn ) -> (([Name L],L))+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+happyIn97 :: (([FunDep L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn ) -> (([FunDep L],[S],Maybe L))+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+happyIn98 :: (([FunDep L],[S],L)) -> (HappyAbsSyn )+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn ) -> (([FunDep L],[S],L))+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+happyIn99 :: (FunDep L) -> (HappyAbsSyn )+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn ) -> (FunDep L)+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+happyIn100 :: (([GadtDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn ) -> (([GadtDecl L],[S],Maybe L))+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+happyIn101 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+happyIn102 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+happyIn103 :: (GadtDecl L) -> (HappyAbsSyn )+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn ) -> (GadtDecl L)+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+happyIn104 :: (([QualConDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],Maybe L))+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+happyIn105 :: (([QualConDecl L],[S],L)) -> (HappyAbsSyn )+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],L))+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+happyIn106 :: (QualConDecl L) -> (HappyAbsSyn )+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn ) -> (QualConDecl L)+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+happyIn107 :: ((Maybe [TyVarBind L], [S], Maybe L)) -> (HappyAbsSyn )+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn ) -> ((Maybe [TyVarBind L], [S], Maybe L))+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+happyIn108 :: (ConDecl L) -> (HappyAbsSyn )+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn ) -> (ConDecl L)+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+happyIn109 :: ((Name L, [BangType L], L)) -> (HappyAbsSyn )+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn ) -> ((Name L, [BangType L], L))+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+happyIn110 :: ((Name L, [BangType L],L)) -> (HappyAbsSyn )+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn ) -> ((Name L, [BangType L],L))+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+happyIn111 :: (BangType L) -> (HappyAbsSyn )+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn ) -> (BangType L)+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+happyIn112 :: (BangType L) -> (HappyAbsSyn )+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn ) -> (BangType L)+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+happyIn113 :: (([FieldDecl L],[S])) -> (HappyAbsSyn )+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn ) -> (([FieldDecl L],[S]))+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+happyIn114 :: (FieldDecl L) -> (HappyAbsSyn )+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn ) -> (FieldDecl L)+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+happyIn115 :: (BangType L) -> (HappyAbsSyn )+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn ) -> (BangType L)+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+happyIn116 :: (Maybe (Deriving L)) -> (HappyAbsSyn )+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn ) -> (Maybe (Deriving L))+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+happyIn117 :: (([InstHead L],[S])) -> (HappyAbsSyn )+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn ) -> (([InstHead L],[S]))+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+happyIn118 :: (QName L) -> (HappyAbsSyn )+happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn118 #-}+happyOut118 :: (HappyAbsSyn ) -> (QName L)+happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut118 #-}+happyIn119 :: (Kind L) -> (HappyAbsSyn )+happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn119 #-}+happyOut119 :: (HappyAbsSyn ) -> (Kind L)+happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut119 #-}+happyIn120 :: (Kind L) -> (HappyAbsSyn )+happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn120 #-}+happyOut120 :: (HappyAbsSyn ) -> (Kind L)+happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut120 #-}+happyIn121 :: (Kind L) -> (HappyAbsSyn )+happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn121 #-}+happyOut121 :: (HappyAbsSyn ) -> (Kind L)+happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut121 #-}+happyIn122 :: ((Maybe (Kind L), [S])) -> (HappyAbsSyn )+happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn122 #-}+happyOut122 :: (HappyAbsSyn ) -> ((Maybe (Kind L), [S]))+happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut122 #-}+happyIn123 :: ((Maybe [ClassDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn123 #-}+happyOut123 :: (HappyAbsSyn ) -> ((Maybe [ClassDecl L],[S],Maybe L))+happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut123 #-}+happyIn124 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )+happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn124 #-}+happyOut124 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))+happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut124 #-}+happyIn125 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )+happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn125 #-}+happyOut125 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))+happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut125 #-}+happyIn126 :: (ClassDecl L) -> (HappyAbsSyn )+happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn126 #-}+happyOut126 :: (HappyAbsSyn ) -> (ClassDecl L)+happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut126 #-}+happyIn127 :: (ClassDecl L) -> (HappyAbsSyn )+happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn127 #-}+happyOut127 :: (HappyAbsSyn ) -> (ClassDecl L)+happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut127 #-}+happyIn128 :: ((Maybe [InstDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn128 #-}+happyOut128 :: (HappyAbsSyn ) -> ((Maybe [InstDecl L],[S],Maybe L))+happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut128 #-}+happyIn129 :: (([InstDecl L],[S])) -> (HappyAbsSyn )+happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn129 #-}+happyOut129 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))+happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut129 #-}+happyIn130 :: (([InstDecl L],[S])) -> (HappyAbsSyn )+happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn130 #-}+happyOut130 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))+happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut130 #-}+happyIn131 :: (InstDecl L) -> (HappyAbsSyn )+happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn131 #-}+happyOut131 :: (HappyAbsSyn ) -> (InstDecl L)+happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut131 #-}+happyIn132 :: (InstDecl L) -> (HappyAbsSyn )+happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn132 #-}+happyOut132 :: (HappyAbsSyn ) -> (InstDecl L)+happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut132 #-}+happyIn133 :: (Decl L) -> (HappyAbsSyn )+happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn133 #-}+happyOut133 :: (HappyAbsSyn ) -> (Decl L)+happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut133 #-}+happyIn134 :: ((Maybe (Binds L),[S])) -> (HappyAbsSyn )+happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn134 #-}+happyOut134 :: (HappyAbsSyn ) -> ((Maybe (Binds L),[S]))+happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut134 #-}+happyIn135 :: ((Maybe (Type L),[S])) -> (HappyAbsSyn )+happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn135 #-}+happyOut135 :: (HappyAbsSyn ) -> ((Maybe (Type L),[S]))+happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut135 #-}+happyIn136 :: (Rhs L) -> (HappyAbsSyn )+happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn136 #-}+happyOut136 :: (HappyAbsSyn ) -> (Rhs L)+happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut136 #-}+happyIn137 :: (([GuardedRhs L],L)) -> (HappyAbsSyn )+happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn137 #-}+happyOut137 :: (HappyAbsSyn ) -> (([GuardedRhs L],L))+happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut137 #-}+happyIn138 :: (GuardedRhs L) -> (HappyAbsSyn )+happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn138 #-}+happyOut138 :: (HappyAbsSyn ) -> (GuardedRhs L)+happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut138 #-}+happyIn139 :: (Exp L) -> (HappyAbsSyn )+happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn139 #-}+happyOut139 :: (HappyAbsSyn ) -> (Exp L)+happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut139 #-}+happyIn140 :: (PExp L) -> (HappyAbsSyn )+happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn140 #-}+happyOut140 :: (HappyAbsSyn ) -> (PExp L)+happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut140 #-}+happyIn141 :: (PExp L) -> (HappyAbsSyn )+happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn141 #-}+happyOut141 :: (HappyAbsSyn ) -> (PExp L)+happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut141 #-}+happyIn142 :: (PExp L) -> (HappyAbsSyn )+happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn142 #-}+happyOut142 :: (HappyAbsSyn ) -> (PExp L)+happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut142 #-}+happyIn143 :: (PExp L) -> (HappyAbsSyn )+happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn143 #-}+happyOut143 :: (HappyAbsSyn ) -> (PExp L)+happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut143 #-}+happyIn144 :: (PExp L) -> (HappyAbsSyn )+happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn144 #-}+happyOut144 :: (HappyAbsSyn ) -> (PExp L)+happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut144 #-}+happyIn145 :: (PExp L) -> (HappyAbsSyn )+happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn145 #-}+happyOut145 :: (HappyAbsSyn ) -> (PExp L)+happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut145 #-}+happyIn146 :: (PExp L) -> (HappyAbsSyn )+happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn146 #-}+happyOut146 :: (HappyAbsSyn ) -> (PExp L)+happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut146 #-}+happyIn147 :: (PExp L) -> (HappyAbsSyn )+happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn147 #-}+happyOut147 :: (HappyAbsSyn ) -> (PExp L)+happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut147 #-}+happyIn148 :: ([Pat L]) -> (HappyAbsSyn )+happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn148 #-}+happyOut148 :: (HappyAbsSyn ) -> ([Pat L])+happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut148 #-}+happyIn149 :: (Pat L) -> (HappyAbsSyn )+happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn149 #-}+happyOut149 :: (HappyAbsSyn ) -> (Pat L)+happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut149 #-}+happyIn150 :: (PExp L) -> (HappyAbsSyn )+happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn150 #-}+happyOut150 :: (HappyAbsSyn ) -> (PExp L)+happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut150 #-}+happyIn151 :: (PExp L) -> (HappyAbsSyn )+happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn151 #-}+happyOut151 :: (HappyAbsSyn ) -> (PExp L)+happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut151 #-}+happyIn152 :: (PExp L) -> (HappyAbsSyn )+happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn152 #-}+happyOut152 :: (HappyAbsSyn ) -> (PExp L)+happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut152 #-}+happyIn153 :: ([S]) -> (HappyAbsSyn )+happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn153 #-}+happyOut153 :: (HappyAbsSyn ) -> ([S])+happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut153 #-}+happyIn154 :: (PExp L) -> (HappyAbsSyn )+happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn154 #-}+happyOut154 :: (HappyAbsSyn ) -> (PExp L)+happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut154 #-}+happyIn155 :: (([Maybe (PExp L)],[S])) -> (HappyAbsSyn )+happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn155 #-}+happyOut155 :: (HappyAbsSyn ) -> (([Maybe (PExp L)],[S]))+happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut155 #-}+happyIn156 :: (([PExp L],[S])) -> (HappyAbsSyn )+happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn156 #-}+happyOut156 :: (HappyAbsSyn ) -> (([PExp L],[S]))+happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut156 #-}+happyIn157 :: (PExp L) -> (HappyAbsSyn )+happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn157 #-}+happyOut157 :: (HappyAbsSyn ) -> (PExp L)+happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut157 #-}+happyIn158 :: (PExp L) -> (HappyAbsSyn )+happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn158 #-}+happyOut158 :: (HappyAbsSyn ) -> (PExp L)+happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut158 #-}+happyIn159 :: ([PExp L]) -> (HappyAbsSyn )+happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn159 #-}+happyOut159 :: (HappyAbsSyn ) -> ([PExp L])+happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut159 #-}+happyIn160 :: (PExp L) -> (HappyAbsSyn )+happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn160 #-}+happyOut160 :: (HappyAbsSyn ) -> (PExp L)+happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut160 #-}+happyIn161 :: (XName L) -> (HappyAbsSyn )+happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn161 #-}+happyOut161 :: (HappyAbsSyn ) -> (XName L)+happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut161 #-}+happyIn162 :: (Loc String) -> (HappyAbsSyn )+happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn162 #-}+happyOut162 :: (HappyAbsSyn ) -> (Loc String)+happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut162 #-}+happyIn163 :: (Loc String) -> (HappyAbsSyn )+happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn163 #-}+happyOut163 :: (HappyAbsSyn ) -> (Loc String)+happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut163 #-}+happyIn164 :: ([ParseXAttr L]) -> (HappyAbsSyn )+happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn164 #-}+happyOut164 :: (HappyAbsSyn ) -> ([ParseXAttr L])+happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut164 #-}+happyIn165 :: (ParseXAttr L) -> (HappyAbsSyn )+happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn165 #-}+happyOut165 :: (HappyAbsSyn ) -> (ParseXAttr L)+happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut165 #-}+happyIn166 :: (Maybe (PExp L)) -> (HappyAbsSyn )+happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn166 #-}+happyOut166 :: (HappyAbsSyn ) -> (Maybe (PExp L))+happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut166 #-}+happyIn167 :: (L -> PExp L) -> (HappyAbsSyn )+happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn167 #-}+happyOut167 :: (HappyAbsSyn ) -> (L -> PExp L)+happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut167 #-}+happyIn168 :: (([PExp L],[S])) -> (HappyAbsSyn )+happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn168 #-}+happyOut168 :: (HappyAbsSyn ) -> (([PExp L],[S]))+happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut168 #-}+happyIn169 :: (([[QualStmt L]],[S])) -> (HappyAbsSyn )+happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn169 #-}+happyOut169 :: (HappyAbsSyn ) -> (([[QualStmt L]],[S]))+happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut169 #-}+happyIn170 :: (([QualStmt L],[S])) -> (HappyAbsSyn )+happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn170 #-}+happyOut170 :: (HappyAbsSyn ) -> (([QualStmt L],[S]))+happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut170 #-}+happyIn171 :: (QualStmt L) -> (HappyAbsSyn )+happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn171 #-}+happyOut171 :: (HappyAbsSyn ) -> (QualStmt L)+happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut171 #-}+happyIn172 :: (QualStmt L) -> (HappyAbsSyn )+happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn172 #-}+happyOut172 :: (HappyAbsSyn ) -> (QualStmt L)+happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut172 #-}+happyIn173 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn173 #-}+happyOut173 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut173 #-}+happyIn174 :: (Stmt L) -> (HappyAbsSyn )+happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn174 #-}+happyOut174 :: (HappyAbsSyn ) -> (Stmt L)+happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut174 #-}+happyIn175 :: (([Alt L],L,[S])) -> (HappyAbsSyn )+happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn175 #-}+happyOut175 :: (HappyAbsSyn ) -> (([Alt L],L,[S]))+happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut175 #-}+happyIn176 :: (([Alt L],[S])) -> (HappyAbsSyn )+happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn176 #-}+happyOut176 :: (HappyAbsSyn ) -> (([Alt L],[S]))+happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut176 #-}+happyIn177 :: (([Alt L],[S])) -> (HappyAbsSyn )+happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn177 #-}+happyOut177 :: (HappyAbsSyn ) -> (([Alt L],[S]))+happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut177 #-}+happyIn178 :: (Alt L) -> (HappyAbsSyn )+happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn178 #-}+happyOut178 :: (HappyAbsSyn ) -> (Alt L)+happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut178 #-}+happyIn179 :: (GuardedAlts L) -> (HappyAbsSyn )+happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn179 #-}+happyOut179 :: (HappyAbsSyn ) -> (GuardedAlts L)+happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut179 #-}+happyIn180 :: (([GuardedAlt L],L)) -> (HappyAbsSyn )+happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn180 #-}+happyOut180 :: (HappyAbsSyn ) -> (([GuardedAlt L],L))+happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut180 #-}+happyIn181 :: (GuardedAlt L) -> (HappyAbsSyn )+happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn181 #-}+happyOut181 :: (HappyAbsSyn ) -> (GuardedAlt L)+happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut181 #-}+happyIn182 :: (Pat L) -> (HappyAbsSyn )+happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn182 #-}+happyOut182 :: (HappyAbsSyn ) -> (Pat L)+happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut182 #-}+happyIn183 :: (([Stmt L],L,[S])) -> (HappyAbsSyn )+happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn183 #-}+happyOut183 :: (HappyAbsSyn ) -> (([Stmt L],L,[S]))+happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut183 #-}+happyIn184 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn184 #-}+happyOut184 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut184 #-}+happyIn185 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn185 #-}+happyOut185 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut185 #-}+happyIn186 :: (Stmt L) -> (HappyAbsSyn )+happyIn186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn186 #-}+happyOut186 :: (HappyAbsSyn ) -> (Stmt L)+happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut186 #-}+happyIn187 :: (([PFieldUpdate L],[S])) -> (HappyAbsSyn )+happyIn187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn187 #-}+happyOut187 :: (HappyAbsSyn ) -> (([PFieldUpdate L],[S]))+happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut187 #-}+happyIn188 :: (PFieldUpdate L) -> (HappyAbsSyn )+happyIn188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn188 #-}+happyOut188 :: (HappyAbsSyn ) -> (PFieldUpdate L)+happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut188 #-}+happyIn189 :: (([IPBind L],[S])) -> (HappyAbsSyn )+happyIn189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn189 #-}+happyOut189 :: (HappyAbsSyn ) -> (([IPBind L],[S]))+happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut189 #-}+happyIn190 :: (([IPBind L],[S])) -> (HappyAbsSyn )+happyIn190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn190 #-}+happyOut190 :: (HappyAbsSyn ) -> (([IPBind L],[S]))+happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut190 #-}+happyIn191 :: (IPBind L) -> (HappyAbsSyn )+happyIn191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn191 #-}+happyOut191 :: (HappyAbsSyn ) -> (IPBind L)+happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut191 #-}+happyIn192 :: (PExp L) -> (HappyAbsSyn )+happyIn192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn192 #-}+happyOut192 :: (HappyAbsSyn ) -> (PExp L)+happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut192 #-}+happyIn193 :: (Name L) -> (HappyAbsSyn )+happyIn193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn193 #-}+happyOut193 :: (HappyAbsSyn ) -> (Name L)+happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut193 #-}+happyIn194 :: (Name L) -> (HappyAbsSyn )+happyIn194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn194 #-}+happyOut194 :: (HappyAbsSyn ) -> (Name L)+happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut194 #-}+happyIn195 :: (QName L) -> (HappyAbsSyn )+happyIn195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn195 #-}+happyOut195 :: (HappyAbsSyn ) -> (QName L)+happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut195 #-}+happyIn196 :: (IPName L) -> (HappyAbsSyn )+happyIn196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn196 #-}+happyOut196 :: (HappyAbsSyn ) -> (IPName L)+happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut196 #-}+happyIn197 :: (Name L) -> (HappyAbsSyn )+happyIn197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn197 #-}+happyOut197 :: (HappyAbsSyn ) -> (Name L)+happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut197 #-}+happyIn198 :: (QName L) -> (HappyAbsSyn )+happyIn198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn198 #-}+happyOut198 :: (HappyAbsSyn ) -> (QName L)+happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut198 #-}+happyIn199 :: (Name L) -> (HappyAbsSyn )+happyIn199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn199 #-}+happyOut199 :: (HappyAbsSyn ) -> (Name L)+happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut199 #-}+happyIn200 :: (QName L) -> (HappyAbsSyn )+happyIn200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn200 #-}+happyOut200 :: (HappyAbsSyn ) -> (QName L)+happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut200 #-}+happyIn201 :: (QName L) -> (HappyAbsSyn )+happyIn201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn201 #-}+happyOut201 :: (HappyAbsSyn ) -> (QName L)+happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut201 #-}+happyIn202 :: (Name L) -> (HappyAbsSyn )+happyIn202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn202 #-}+happyOut202 :: (HappyAbsSyn ) -> (Name L)+happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut202 #-}+happyIn203 :: (QName L) -> (HappyAbsSyn )+happyIn203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn203 #-}+happyOut203 :: (HappyAbsSyn ) -> (QName L)+happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut203 #-}+happyIn204 :: (Op L) -> (HappyAbsSyn )+happyIn204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn204 #-}+happyOut204 :: (HappyAbsSyn ) -> (Op L)+happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut204 #-}+happyIn205 :: (QOp L) -> (HappyAbsSyn )+happyIn205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn205 #-}+happyOut205 :: (HappyAbsSyn ) -> (QOp L)+happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut205 #-}+happyIn206 :: (QOp L) -> (HappyAbsSyn )+happyIn206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn206 #-}+happyOut206 :: (HappyAbsSyn ) -> (QOp L)+happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut206 #-}+happyIn207 :: (QName L) -> (HappyAbsSyn )+happyIn207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn207 #-}+happyOut207 :: (HappyAbsSyn ) -> (QName L)+happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut207 #-}+happyIn208 :: (QName L) -> (HappyAbsSyn )+happyIn208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn208 #-}+happyOut208 :: (HappyAbsSyn ) -> (QName L)+happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut208 #-}+happyIn209 :: (Name L) -> (HappyAbsSyn )+happyIn209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn209 #-}+happyOut209 :: (HappyAbsSyn ) -> (Name L)+happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut209 #-}+happyIn210 :: (Name L) -> (HappyAbsSyn )+happyIn210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn210 #-}+happyOut210 :: (HappyAbsSyn ) -> (Name L)+happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut210 #-}+happyIn211 :: (IPName L) -> (HappyAbsSyn )+happyIn211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn211 #-}+happyOut211 :: (HappyAbsSyn ) -> (IPName L)+happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut211 #-}+happyIn212 :: (QName L) -> (HappyAbsSyn )+happyIn212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn212 #-}+happyOut212 :: (HappyAbsSyn ) -> (QName L)+happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut212 #-}+happyIn213 :: (Name L) -> (HappyAbsSyn )+happyIn213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn213 #-}+happyOut213 :: (HappyAbsSyn ) -> (Name L)+happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut213 #-}+happyIn214 :: (QName L) -> (HappyAbsSyn )+happyIn214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn214 #-}+happyOut214 :: (HappyAbsSyn ) -> (QName L)+happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut214 #-}+happyIn215 :: (Name L) -> (HappyAbsSyn )+happyIn215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn215 #-}+happyOut215 :: (HappyAbsSyn ) -> (Name L)+happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut215 #-}+happyIn216 :: (QName L) -> (HappyAbsSyn )+happyIn216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn216 #-}+happyOut216 :: (HappyAbsSyn ) -> (QName L)+happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut216 #-}+happyIn217 :: (QName L) -> (HappyAbsSyn )+happyIn217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn217 #-}+happyOut217 :: (HappyAbsSyn ) -> (QName L)+happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut217 #-}+happyIn218 :: (Name L) -> (HappyAbsSyn )+happyIn218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn218 #-}+happyOut218 :: (HappyAbsSyn ) -> (Name L)+happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut218 #-}+happyIn219 :: (Name L) -> (HappyAbsSyn )+happyIn219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn219 #-}+happyOut219 :: (HappyAbsSyn ) -> (Name L)+happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut219 #-}+happyIn220 :: (QName L) -> (HappyAbsSyn )+happyIn220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn220 #-}+happyOut220 :: (HappyAbsSyn ) -> (QName L)+happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut220 #-}+happyIn221 :: (Literal L) -> (HappyAbsSyn )+happyIn221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn221 #-}+happyOut221 :: (HappyAbsSyn ) -> (Literal L)+happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut221 #-}+happyIn222 :: (S) -> (HappyAbsSyn )+happyIn222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn222 #-}+happyOut222 :: (HappyAbsSyn ) -> (S)+happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut222 #-}+happyIn223 :: (S) -> (HappyAbsSyn )+happyIn223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn223 #-}+happyOut223 :: (HappyAbsSyn ) -> (S)+happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut223 #-}+happyIn224 :: (ModuleName L) -> (HappyAbsSyn )+happyIn224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn224 #-}+happyOut224 :: (HappyAbsSyn ) -> (ModuleName L)+happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut224 #-}+happyIn225 :: (Name L) -> (HappyAbsSyn )+happyIn225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn225 #-}+happyOut225 :: (HappyAbsSyn ) -> (Name L)+happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut225 #-}+happyIn226 :: (QName L) -> (HappyAbsSyn )+happyIn226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn226 #-}+happyOut226 :: (HappyAbsSyn ) -> (QName L)+happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut226 #-}+happyIn227 :: (Name L) -> (HappyAbsSyn )+happyIn227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn227 #-}+happyOut227 :: (HappyAbsSyn ) -> (Name L)+happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut227 #-}+happyIn228 :: (QName L) -> (HappyAbsSyn )+happyIn228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn228 #-}+happyOut228 :: (HappyAbsSyn ) -> (QName L)+happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut228 #-}+happyIn229 :: (Name L) -> (HappyAbsSyn )+happyIn229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn229 #-}+happyOut229 :: (HappyAbsSyn ) -> (Name L)+happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut229 #-}+happyInTok :: (Loc Token) -> (HappyAbsSyn )+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> (Loc Token)+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\x00\x00\xe8\x11\x70\x11\x9e\x09\xca\x18\x18\x0f\x00\x00\x00\x00\x00\x00\x07\x08\x14\x07\x6c\x08\xe2\x07\x00\x00\x46\x08\x00\x00\x00\x00\x17\x16\x00\x00\x00\x00\x00\x00\xd7\x16\x00\x00\x44\x08\x00\x00\x00\x00\x3b\x08\xd2\x07\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\x36\x0c\x32\x02\xb7\x0c\x00\x00\x00\x00\x7d\x16\xd7\x16\xd7\x16\xd7\x16\xe8\x11\x00\x00\xe8\x11\xe8\x11\xe8\x11\xca\x18\x00\x00\xb9\x19\xea\x19\x00\x00\x38\x0d\xfe\x16\xe8\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x11\x43\x08\x00\x00\xe8\x11\x41\x08\x3f\x08\x7d\x16\x3f\x08\x00\x00\x4b\x08\x49\x08\x48\x08\x00\x00\x00\x00\xb0\x17\x00\x00\x00\x00\x00\x00\xc6\x07\x00\x00\xca\x18\x22\x08\x00\x00\x00\x00\x00\x00\x76\x17\x18\x18\xc3\x18\x00\x00\x00\x00\x3e\x08\xc0\x07\x60\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x1b\xd7\x16\xb3\x00\x9a\x18\xe6\x07\x31\x08\xd9\x07\x00\x00\x00\x00\x00\x00\x9a\x18\x29\x08\x00\x00\x24\x19\x23\x08\x23\x08\x5e\x1a\x23\x08\x35\x08\xa7\x1a\xa7\x1a\x2e\x1a\x00\x00\xb9\x07\xb9\x07\x00\x00\xb9\x07\xf8\xff\x00\x00\x00\x00\x1f\x08\xfe\x16\xd0\x07\x98\x06\xd7\x16\xb8\x07\x00\x00\x00\x00\x00\x00\x00\x00\x56\x03\xd7\x16\x34\x08\x14\x00\x00\x00\x28\x08\x14\x08\x13\x00\x0c\x00\x00\x00\x0e\x08\x93\x1a\x20\x00\x04\x08\x4c\x01\x9a\x18\x93\x1a\x93\x1a\x02\x08\xea\x17\xf3\x18\xb0\x19\x00\x00\xb7\x07\x00\x00\x00\x00\xb4\x07\x9a\x18\x9a\x18\x9a\x18\xf2\x07\x23\x06\x23\x06\x8d\x04\x8d\x04\x00\x00\x00\x00\xe8\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x1a\x1d\x04\x00\x00\x00\x00\x9a\x18\x00\x00\x00\x00\x00\x00\x61\x06\x9a\x18\x38\x01\x00\x00\x93\x14\xfc\x07\x00\x00\x00\x00\x15\x02\xea\x01\x00\x00\x00\x00\x5e\x00\x01\x08\xf3\x07\xca\x01\xf8\x07\xf7\x07\x00\x00\xf6\x07\xb0\x19\x00\x00\x00\x00\xb0\x19\x00\x00\xb0\x19\x00\x00\x00\x00\x3c\x17\x9a\x18\xb0\x19\x00\x00\xfb\x07\x7e\x07\x7d\x07\x00\x00\xb0\x0d\xb0\x0d\xcd\x07\x00\x00\xd7\x16\x00\x00\x92\x07\x83\x07\x00\x00\x88\x07\xd8\x07\xb1\x07\x00\x00\xcc\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\xbf\x07\xaf\x07\x00\x00\x00\x00\xe8\x11\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x0a\xc0\x01\xc8\x07\x00\x00\x00\x00\x91\x02\x9e\x09\xb3\x07\xa6\x07\x1e\x0a\x9d\x07\xbc\x07\xb2\x07\x01\x01\x00\x00\xd7\x16\x00\x00\x23\x16\x00\x00\x16\x02\xad\x07\x98\x07\x00\x00\xa9\x01\x00\x00\x54\x03\xb5\x0b\xc8\x01\xb6\x07\xb0\x07\xae\x07\xac\x07\xab\x07\x00\x00\xaa\x07\xd7\x16\xa9\x07\xa2\x07\xf3\x18\xd7\x16\xd7\x16\xe8\x11\x1a\x14\x00\x00\xe8\x11\x9a\x18\xe8\x11\xe8\x11\xe8\x11\xe8\x11\x36\x00\x91\x07\x00\x00\xa7\x07\x1a\x1a\x00\x00\xd0\xff\x00\x00\x2b\x07\x00\x00\x84\x07\x00\x00\x03\x00\x14\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x02\x00\x00\x7b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x07\x00\x00\x00\x00\x00\x00\x00\x00\x34\x0b\x00\x00\x00\x00\x6e\x01\x00\x00\x00\x00\xe8\x11\xe8\x11\x00\x00\x38\x0d\x00\x00\x38\x0d\xe8\x11\xa0\x0e\x00\x00\xe8\x11\xe8\x11\x00\x00\xf8\x10\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x00\x00\x86\x07\x77\x07\x70\x07\x00\x00\x00\x00\xfe\x16\x3d\x15\x00\x00\x00\x00\x00\x00\x00\x00\x42\x07\xe8\x11\x6e\x07\xe8\x11\xe8\x11\x00\x00\xe8\x11\x67\x07\x59\x07\xb0\x0d\x36\x00\xe8\x11\xe8\x11\x58\x07\x54\x19\x00\x00\x48\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x18\x00\x00\x00\x00\x15\x01\x00\x00\x00\x00\x9a\x18\x00\x00\x00\x00\x00\x00\xde\x18\x9a\x18\x47\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x19\x61\x06\x03\x07\xea\x06\x15\x01\xf6\x06\xbc\x03\x33\x07\xbc\x01\x00\x00\xdf\x06\x24\x07\x00\x00\xe8\x11\xf8\x10\xd7\x06\x28\x07\x00\x00\x00\x00\x66\x08\xd3\x06\x00\x00\x1f\x07\x2f\x07\x00\x00\x20\x07\x00\x00\x00\x00\x00\x00\x26\x07\xd4\x13\x1d\x07\x1c\x07\x36\x00\x36\x00\x0c\x07\x00\x00\xfd\x06\xb0\x19\x9a\x18\xac\x06\xa7\x06\x9d\x06\x9a\x18\x00\x07\x07\x07\xe9\x06\xbc\x06\xff\x06\x00\x00\x8c\x1a\x00\x00\x8c\x1a\x00\x00\x00\x00\xd7\x16\x00\x00\xf5\x06\xec\x06\x00\x00\x00\x00\xf3\x05\x00\x00\x00\x00\xb3\x06\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x06\x90\x08\x36\x00\x3d\x15\xb4\x06\xe3\x06\xe6\x06\xdc\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x11\xd8\x1a\x9a\x18\xc9\x06\x00\x00\x5e\x06\xb9\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x19\x00\x00\x9a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x17\x00\x00\x00\x00\xba\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x18\xa5\x06\xaf\x06\x00\x00\x00\x00\xb0\x06\x00\x00\x9b\x06\x00\x00\x7f\x0d\x54\x01\x66\x08\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x06\x00\x00\xe3\x01\x00\x00\x92\x06\xa0\x06\x00\x00\x00\x00\x00\x00\xc4\x1a\x9a\x18\x00\x00\x85\x06\x00\x00\xb7\x0a\x00\x00\x00\x00\x00\x00\x82\x06\x15\x01\x00\x00\x00\x00\x4d\x06\x8d\x06\x00\x00\xba\x01\x3a\x06\x0f\x06\x72\x06\x5f\x06\x38\x01\x00\x00\x48\x06\x00\x00\x56\x06\x3c\x06\x00\x00\x00\x00\x50\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x0d\x00\x00\x00\x00\x00\x00\xf2\x05\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\x06\x00\x00\x15\x06\x84\x04\x79\x04\x37\x04\x23\x04\xee\x03\xae\x03\x99\x03\x8f\x03\x6a\x03\x45\x03\x3b\x03\x00\x00\x00\x00\x00\x00\x9e\x09\x2e\x06\x06\x06\xf0\x00\x00\x00\x00\x00\x0b\x06\x24\x06\x00\x00\x00\x00\x00\x00\x80\x10\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\xfc\x05\x00\x00\x00\x00\x00\x00\x5f\x01\x00\x00\x00\x00\xe8\x11\x00\x00\x0f\x15\x00\x00\x00\x00\x30\x06\xfb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x11\xca\x05\x9e\x00\xa0\x0e\xa0\x0e\x08\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x16\x00\x00\x28\x0e\x04\x06\x36\x00\xe8\x11\x00\x00\xe3\x05\x00\x00\x15\x01\x00\x00\x00\x00\x00\x00\xb2\x05\x00\x00\x00\x00\x00\x00\x31\x18\x00\x00\x00\x00\x00\x00\xf8\x05\x15\x01\xa6\x13\x00\x00\x0c\x0a\xb7\x0a\x00\x00\x00\x00\xa3\x0a\x48\x00\xe5\x05\xe1\x05\x76\x17\xb0\x19\x74\x05\x8a\x05\x00\x00\x00\x00\x54\x01\x81\x05\xe8\x11\xe8\x11\x00\x00\x00\x00\xce\x05\xb5\x05\xb0\x19\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x15\x58\x13\xb8\x05\x36\x00\xe8\x11\x4b\x06\xa6\x05\xb5\x15\xc1\x14\xa6\x05\x00\x00\x9a\x18\x00\x00\x00\x00\x3e\x05\x9a\x05\xbd\x1a\x00\x00\xdc\x07\x89\x05\x27\x05\x25\x05\x29\x05\x00\x00\x32\x0a\x00\x00\xee\x05\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x05\x00\x00\x15\x05\x12\x05\x17\x09\x6d\x05\x00\x00\x00\x00\x70\x05\x58\x05\x00\x00\x00\x00\x00\x00\x60\x05\x00\x00\xed\x05\x00\x00\x00\x00\x00\x00\xe8\x11\x4b\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x05\x00\x00\x00\x00\x00\x00\x9a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x0e\x00\x00\xb0\x19\x00\x00\x00\x00\x60\x12\x43\x05\x36\x00\x00\x00\xb0\x19\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x05\x00\x00\x00\x00\x3a\x05\xae\x12\x8d\x0a\x46\x05\x00\x00\x00\x00\xb0\x19\xd1\x04\x46\x0a\x00\x00\xb0\x19\xb0\x19\xc5\x04\x00\x00\x00\x00\x00\x00\x45\x01\x2b\x05\x36\x00\x1c\x05\x23\x05\x00\x00\x00\x00\x21\x05\x1b\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x03\x00\x00\xd5\x04\x00\x00\x09\x05\x00\x00\xe8\x11\xe8\x11\xe8\x11\x00\x00\x00\x00\x00\x00\xad\x04\xfe\x16\xa5\x04\xe8\x04\x00\x00\x08\x10\xe8\x11\x90\x0f\xfc\x04\xea\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x04\x32\x00\xd6\x04\x00\x00\x4d\x19\xce\x04\x00\x00\xb0\x19\x00\x00\xea\x00\x64\x00\x00\x00\x00\x00\xe2\x04\xb0\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x18\xf3\x18\xd3\x04\x9a\x18\x45\x14\xda\x04\xaa\x05\x9a\x18\x00\x00\x00\x00\x13\x1a\xe4\x04\x89\x19\x00\x00\xc0\x02\x00\x00\x00\x00\x00\x00\xe3\x04\x00\x00\xcb\x05\x00\x00\xfe\x16\x00\x00\x00\x00\x1d\x01\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x04\xc9\x04\x7f\x04\x59\x04\x00\x00\x00\x00\x9a\x18\xaf\x04\xac\x04\xa0\x04\xa0\x04\xdc\x12\xab\x04\x00\x00\x00\x00\x2a\x13\x2a\x0a\x7e\x19\x7e\x19\x9a\x18\x37\x01\xab\x04\xb6\x04\x00\x00\x00\x00\x87\x01\x00\x00\x00\x00\x5e\x04\xe8\x11\x00\x00\x00\x00\xe8\x11\x33\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x19\x12\x04\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x18\x00\x00\x2e\x04\x00\x00\x00\x00\x00\x00\x00\x00\x78\x1a\x39\x04\x2a\x04\x1f\x00\xcb\x05\x00\x00\x00\x00\x00\x00\x00\x00\x34\x04\x00\x00\xe8\x11\x00\x00\x00\x00\x7e\x19\x00\x00\x00\x00\x00\x00\x4d\x04\x00\x00\x4f\x16\x00\x00\x3a\x04\x0f\x04\x00\x00\x00\x00\x00\x00\x1f\x04\x35\x12\x16\x04\x78\x1a\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x13\x04\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\x02\x00\x97\x21\x35\x24\xae\x01\xdc\x05\x4f\x1e\x01\x00\xff\xff\xfe\xff\x71\x02\x65\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x08\x00\x00\x00\x00\x00\x00\xa9\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x21\x82\x03\xff\x21\x00\x00\x00\x00\xa3\x29\x8e\x2b\x61\x29\x67\x2b\x1f\x24\x00\x00\x44\x21\x2e\x21\xed\x28\xc9\x05\x2f\x03\x5f\x03\x88\x01\x00\x00\xfd\x22\xdb\x06\x45\x28\x72\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x28\x92\xff\x00\x00\xdd\x27\xef\xff\x8c\xff\xfa\x29\x81\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x06\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x04\xb9\x04\x02\x07\xd5\x03\x00\x00\xca\x03\x00\x00\xc6\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x0a\x4c\x2b\x00\x00\xb1\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x06\xec\xff\x00\x00\xd7\x02\xbd\x03\xb0\x03\xdf\x03\xac\x03\x1e\x05\x75\x03\xbd\x02\x7c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x02\x00\x00\x00\x00\xfc\xff\xc8\x06\x3c\x05\x0b\x03\x36\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x01\x1b\x2b\x12\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x03\xd8\x03\x00\x00\x00\x00\xd1\x01\x77\x06\xc4\x03\x1c\x03\x00\x00\x38\x07\x8b\x06\xd2\x03\x00\x00\x00\x00\x18\x00\x04\x00\x3c\x03\x64\x06\x48\x01\x51\x06\x53\x03\x96\x03\x6e\x03\x5a\x06\x5d\x05\x00\x00\x00\x00\x03\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\x3a\x02\x00\x00\x00\x00\xb6\x05\x00\x00\x00\x00\x00\x00\x3d\x01\xa1\x05\xf9\xff\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\xa4\x01\x00\x00\xb2\x00\x00\x00\x00\x00\xe1\x00\x3e\x06\x8e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x1d\x56\x1d\x00\x00\x00\x00\xf4\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x02\x00\x00\xf8\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\xa4\x28\x00\x00\x00\x00\x00\x00\x00\x00\x08\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\xff\xef\x02\x00\x00\x00\x00\x00\x00\x33\x01\x2b\x01\x00\x00\x00\x00\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x2a\x00\x00\xb9\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x22\xaf\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x29\x00\x00\x00\x00\xee\x06\xc3\x2a\xa8\x2a\xdb\x20\x65\x01\x00\x00\x03\x29\x7a\x05\xc7\x27\x75\x27\x5f\x27\x0d\x27\xcb\x02\x00\x00\x26\x05\x0f\x00\x48\x02\x00\x00\x67\x02\x00\x00\x00\x00\xf8\x04\x00\x00\x00\x00\x00\x00\xbf\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\x8d\x22\x00\x00\x00\x00\xab\x02\x00\x00\x00\x00\xcd\x23\xf7\x26\x00\x00\x6f\x22\x00\x00\x1d\x22\xa5\x26\xbe\x1a\x00\x00\x8f\x26\x3d\x26\x00\x00\x03\x1d\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x02\xb2\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x03\x50\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x23\x83\xff\x27\x26\xd5\x25\x00\x00\xbf\x25\x00\x00\xca\x02\xb0\x1c\x98\x02\x6d\x25\x57\x25\x00\x00\xb4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x06\x00\x00\x00\x00\xc3\x04\x00\x00\x00\x00\x16\x06\x00\x00\x00\x00\x00\x00\x7f\x01\x02\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\xb9\x00\xf7\x02\x04\x03\x9f\x04\x9a\x04\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x02\xd1\x02\x00\x00\xc5\x20\x5d\x1c\xcd\x02\x0f\x03\x00\x00\x00\x00\xea\xff\xc8\x02\xcf\x02\xc3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x02\xf7\x01\x00\x00\x00\x00\x5b\x02\x54\x02\x00\x00\x00\x00\xa9\x02\x91\x04\x67\x05\x00\x00\x00\x00\x00\x00\x7d\x03\x00\x00\x00\x00\x00\x00\xe1\x02\xdd\x02\x00\x00\xa3\x07\x00\x00\x00\x02\x00\x00\x00\x00\x81\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x73\x04\x4f\x04\x00\x00\x67\x00\x1a\x02\x10\x2a\xe3\x02\x98\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x28\x17\x00\x2b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x03\x00\x00\x54\x05\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x04\x00\x00\x7a\x02\x61\x04\x00\x00\x00\x00\x00\x00\x3e\x00\x24\x00\x00\x00\x00\x00\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x00\x00\x00\x00\x00\x00\x89\xff\x06\x02\xd9\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xff\x00\x00\x00\x00\x00\x00\x00\x00\xde\xff\x00\x00\x00\x00\x00\x00\x9f\x00\x41\x05\x00\x00\x00\x00\x00\x00\x25\x07\x79\x02\x00\x00\x00\x00\x00\x00\xd0\x03\x00\x00\x00\x00\x5f\x02\xef\x01\x00\x00\xaa\xff\x52\x02\x50\x02\x00\x00\x00\x00\x58\x01\x00\x00\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\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x00\x00\x00\x00\x05\x25\x00\x00\x18\x03\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x24\x00\x00\x00\x00\x64\x1b\x11\x1b\xfc\x1d\x00\x00\x00\x00\x00\x00\x24\x02\x00\x00\x66\x2a\x00\x00\x4f\x23\x00\x00\xc9\x01\x9d\x24\x00\x00\x00\x00\x00\x00\xd4\x03\x00\x00\x00\x00\x00\x00\x28\x02\x00\x00\x00\x00\x00\x00\xa6\x04\xd9\x00\x50\x00\x00\x00\x00\x00\xb3\x03\x1e\x00\x00\x00\xb4\x03\x4d\x07\x00\x00\x00\x00\x60\x07\xf5\x00\x00\x00\x00\x00\xe9\x03\xd1\x07\x00\x00\x5c\x03\x00\x00\x00\x00\xb7\x01\x00\x00\x5c\x20\x09\x20\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x03\x4a\x00\x2c\x00\xf5\xff\x31\x03\x00\x00\xde\x02\x00\x00\xad\x01\xf3\x1f\xd5\x00\x00\x00\x4b\x29\xc6\x02\x00\x00\x00\x00\x13\x02\x00\x00\x00\x00\x00\x00\x00\x00\xe7\xff\x00\x00\xa1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\x00\x00\x00\x00\x00\x00\xeb\x02\x00\x00\x00\x00\x68\x02\x00\x00\x44\x02\x00\x00\x7d\x00\x00\x00\xbf\x01\x00\x00\x00\x00\x18\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x01\x00\x00\x00\x00\x00\x00\xa0\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x05\x00\x00\x97\x02\x00\x00\x00\x00\x00\x00\x7a\x02\x00\x00\xbe\x03\x00\x00\x00\x00\x1b\x02\x00\x00\x5b\x01\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xff\x55\x01\x7e\x01\x00\x00\x00\x00\xc1\x07\x00\x00\xb4\x03\x00\x00\x4d\x02\xa8\x07\x00\x00\x00\x00\x00\x00\x00\x00\xce\xff\x00\x00\x4d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x02\x00\x00\x64\x03\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x8a\x1f\x37\x1f\x21\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x58\x03\x6d\x01\x31\x01\x00\x00\xb7\x1b\xce\x1e\x65\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x01\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\xb4\x03\x00\x00\x00\x00\xb4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\xef\x05\x90\x03\x00\x00\x19\x05\x32\x03\x00\x00\xdf\xff\x05\x05\x00\x00\x00\x00\x5f\x00\x00\x00\x11\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\xb2\x01\x00\x00\xc0\x00\x00\x00\x37\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\xb5\x00\x00\x00\x00\x00\xf2\x04\x00\x00\x00\x00\xff\x00\xcb\x00\x64\x02\x00\x00\x00\x00\x00\x00\xbd\x00\x05\x04\x8c\x07\x87\x07\xdf\x04\xb0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x1e\x00\x00\x00\x00\x65\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x04\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\xe5\x00\x80\x03\xa3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x24\x00\x00\x00\x00\x12\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\xb1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\xfd\xb1\xfd\x00\x00\xe5\xff\xed\xff\x00\x00\x00\x00\x0c\xfe\xc6\xfe\xc4\xfe\xbe\xfe\xbd\xfe\xbb\xfe\xb9\xfe\xb4\xfe\xaf\xfe\xaa\xfe\xa2\xfe\x9e\xfe\x8f\xfe\x00\x00\x00\x00\x9b\xfe\x9c\xfe\x9d\xfe\xfc\xfd\xf7\xfd\xd5\xfd\xde\xfd\xf5\xfd\xf2\xfd\xcf\xfd\x9a\xfe\xdc\xfd\xdd\xfd\xd1\xfd\xd0\xfd\xcd\xfd\xce\xfd\xbb\xfd\xb9\xfd\xba\xfd\xb8\xfd\xb7\xfd\xb6\xfd\xb5\xfd\xb4\xfd\xb3\xfd\xb2\xfd\x00\x00\x00\x00\x00\x00\x94\xfe\x93\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb1\xfd\x00\x00\x00\x00\x84\xfe\x00\x00\x00\x00\x00\x00\x71\xfe\xd8\xfd\xd4\xfd\xd3\xfd\xd2\xfd\xd7\xfd\xd6\xfd\xdb\xfd\x00\x00\xb1\xfd\xd9\xfd\x00\x00\xb1\xfd\xb1\xfd\x00\x00\xb1\xfd\xda\xfd\x00\x00\x00\x00\x00\x00\x47\xff\x2d\xff\x4e\xff\x44\xff\x42\xff\x3b\xff\x00\x00\x30\xff\x00\x00\x00\x00\xaa\xfd\x34\xff\x41\xff\x00\x00\x00\x00\x00\x00\x26\xff\x85\xff\xad\xff\x00\x00\x00\x00\x90\xff\x86\xff\x7f\xff\x84\xff\x97\xff\xbd\xfe\x00\x00\x00\x00\x00\x00\x8f\xff\x00\x00\x00\x00\xab\xff\xaa\xff\xa9\xff\x00\x00\xb1\xfd\x8e\xff\x00\x00\x64\xff\x64\xff\x00\x00\x64\xff\x66\xff\x58\xff\x58\xff\x00\x00\x17\xfe\x00\x00\x00\x00\xc6\xfe\x00\x00\xe5\xff\xf4\xff\xf2\xff\xb1\xfd\x00\x00\xe5\xff\x00\x00\x00\x00\x00\x00\x53\xff\x54\xff\xfb\xfd\xf4\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x59\xff\x00\x00\x56\xff\x00\x00\x00\x00\x67\xff\x64\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\xff\x00\x00\x00\x00\x76\xff\x00\x00\xd9\xff\xd9\xff\xdc\xfe\x00\x00\x8b\xff\x00\x00\x20\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xfd\xe3\xfd\x00\x00\xe8\xfd\xdf\xfd\xcc\xfd\xee\xfd\xc9\xfd\xc8\xfd\xc5\xfd\xca\xfd\xbc\xfd\xcb\xfd\x00\x00\x00\x00\xc2\xfd\xe0\xfd\x00\x00\xc4\xfd\xc3\xfd\xc1\xfd\xec\xfe\x00\x00\x00\x00\xac\xff\x00\x00\x00\x00\x38\xff\x29\xff\x00\x00\x00\x00\x36\xff\x81\xfe\x29\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\xff\x00\x00\x00\x00\x2e\xff\x45\xff\x00\x00\x31\xff\x00\x00\xa8\xfd\xa7\xfd\x00\x00\x00\x00\x00\x00\x2c\xff\x00\x00\x00\x00\x00\x00\x0b\xfe\x11\xfe\x11\xfe\x00\x00\xa7\xfe\x00\x00\xb0\xfe\x0e\xfe\x00\x00\xb1\xfe\x00\x00\x00\x00\x00\x00\x3f\xfe\x6c\xfe\x68\xfe\x6b\xfe\x6a\xfe\x69\xfe\x64\xfe\x63\xfe\x62\xfe\x61\xfe\x60\xfe\x5f\xfe\x5e\xfe\x5d\xfe\x5c\xfe\x5b\xfe\x66\xfe\x65\xfe\x5a\xfe\x59\xfe\x58\xfe\x57\xfe\x56\xfe\x55\xfe\x54\xfe\x53\xfe\x52\xfe\x51\xfe\x50\xfe\x4f\xfe\x4e\xfe\x4d\xfe\x4c\xfe\x4b\xfe\x4a\xfe\x49\xfe\x48\xfe\x47\xfe\x46\xfe\x45\xfe\x44\xfe\x67\xfe\x43\xfe\x42\xfe\x41\xfe\x80\xfe\x00\x00\xe2\xfd\xe1\xfd\x00\x00\xec\xfd\xc7\xfd\xc6\xfd\xc0\xfd\x00\x00\xbe\xfd\xbf\xfd\xbd\xfd\x85\xfe\x86\xfe\x00\x00\x00\x00\x00\x00\x88\xfe\x87\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xbd\xfe\x00\x00\x00\x00\x79\xfe\x00\x00\x16\xfe\xb2\xfe\xa3\xfe\x00\x00\xa8\xfe\x3b\xfe\x00\x00\x3a\xfe\x00\xfe\x00\x00\xfe\xfd\x80\xfe\x00\x00\x00\x00\x00\x00\xe8\xfd\x00\x00\xc6\xfd\xc0\xfd\x01\xfe\xbe\xfd\xc4\xfd\xbf\xfd\xbd\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\xfe\xc3\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\xf7\xff\xe5\xff\xf6\xff\x00\x00\xd9\xff\xe8\xff\xda\xff\x00\x00\xed\xff\xef\xff\xaf\xfd\xb0\xfd\xbf\xfe\xc0\xfe\xc1\xfe\xc2\xfe\xc5\xfe\xbc\xfe\xba\xfe\x00\x00\x09\xfe\x07\xfe\xa1\xfe\x06\xfe\x0d\xfe\xa4\xfe\xa5\xfe\x00\x00\x49\xff\xf6\xfd\xf1\xfd\x92\xfe\x00\x00\x98\xfe\x99\xfe\x00\x00\xff\xfd\x82\xfe\x00\x00\x00\x00\xfd\xfd\x00\x00\x95\xfe\x00\x00\x39\xfe\x00\x00\xa9\xfe\x00\x00\x00\x00\x91\xfe\x00\x00\x8d\xfe\x8c\xfe\x8b\xfe\x8a\xfe\x00\x00\xd9\xff\xa4\xff\x00\x00\x00\x00\x00\x00\x7f\xfe\x83\xfe\x00\x00\x3c\xfe\x74\xfe\x6e\xfe\x72\xfe\x70\xfe\x00\x00\x00\x00\xb1\xfd\x00\x00\x00\x00\xa6\xfe\x00\x00\x00\x00\x0f\xfe\x11\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x4a\xff\x4b\xff\x00\x00\x4c\xff\x4d\xff\x48\xff\x39\xff\x32\xff\x33\xff\x37\xff\x00\x00\x40\xff\x3d\xff\x00\x00\x35\xff\x3f\xff\x00\x00\x3e\xff\x27\xff\x25\xff\x00\x00\x00\x00\xae\xff\xe6\xfd\xe5\xfd\xa7\xff\xea\xfd\xf0\xfd\x00\x00\xec\xfe\xf8\xfe\x19\xff\x00\x00\x0e\xff\x81\xff\x00\x00\x00\x00\x72\xff\xce\xfe\xca\xfe\xc8\xfe\x00\x00\x00\x00\xce\xfe\x6c\xff\x71\xff\x70\xff\x00\x00\xe8\xfe\x22\xff\xec\xfe\x00\x00\x8c\xff\x49\xff\x8d\xff\x99\xff\x9a\xff\xb1\xfd\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\xff\xec\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\xff\x68\xff\x94\xff\x5a\xff\x93\xff\x00\x00\x57\xff\x92\xff\x00\x00\x51\xff\x00\x00\x00\x00\x91\xff\x50\xff\xe2\xff\xae\xfd\xad\xfd\x00\x00\x3f\xfe\xe7\xff\xd9\xff\xd9\xff\x00\x00\xdc\xff\x00\x00\x3c\xfe\x00\x00\xd7\xff\x00\x00\x00\x00\xfa\xfd\xf3\xfd\x52\xff\x55\xff\x5b\xff\x69\xff\x00\x00\x00\x00\x00\x00\x00\x00\x63\xff\x00\x00\x79\xff\x77\xff\x7a\xff\x7d\xff\x7e\xff\xa3\xff\x4a\xff\xa2\xff\x00\x00\x74\xff\x82\xff\x75\xff\x83\xff\xd9\xff\x87\xff\xcc\xfe\xd9\xff\x03\xfe\x9d\xfe\xdb\xff\xd9\xff\xd9\xff\x98\xff\x9e\xff\x00\x00\x00\x00\x1f\xff\x1d\xff\x9b\xff\xb1\xfd\x95\xff\x00\x00\xf9\xfd\x00\x00\x00\x00\x00\x00\x6f\xff\x6e\xff\x6d\xff\xd0\xfe\xb1\xfd\x24\xfe\x00\x00\x26\xfe\x00\x00\xb1\xfd\xcb\xfe\xc9\xfe\xd1\xfe\x00\x00\x00\x00\xed\xfd\x14\xff\x12\xff\x00\x00\x26\xff\xeb\xfe\xf2\xfe\xf1\xfe\x00\x00\xee\xfe\xef\xfe\xf8\xfe\xb1\xfd\xa0\xff\x00\x00\xf8\xfe\x19\xff\x00\x00\x00\x00\x00\x00\x2f\xff\x00\x00\x28\xff\x00\x00\x2a\xff\xa9\xfd\x2b\xff\x00\x00\xad\xfe\xae\xfe\x14\xfe\x12\xfe\x13\xfe\x11\xfe\x15\xfe\xb5\xfe\xb7\xfe\x00\x00\xb3\xfe\xd9\xff\xd9\xff\x79\xfe\x00\x00\x73\xfe\x3d\xfe\x00\x00\x40\xfe\x00\x00\xdc\xfd\xcd\xfd\xd8\xfd\xd4\xfd\xd3\xfd\xd2\xfd\xd7\xfd\xd6\xfd\xdb\xfd\xd9\xfd\xda\xfd\x6d\xfe\xe7\xfd\xeb\xfd\xda\xff\xa6\xff\x00\x00\x00\x00\x7a\xfe\xb8\xfe\x35\xfe\x31\xfe\x2f\xfe\x2e\xfe\x2d\xfe\x00\x00\x37\xfe\x80\xfe\x33\xfe\x34\xfe\x7e\xfe\x77\xfe\x78\xfe\x96\xfe\x97\xfe\x00\x00\x7b\xfe\x9f\xfe\x00\x00\xa0\xfe\x00\x00\xee\xff\xeb\xff\x00\x00\x00\x00\xea\xff\xec\xff\xe9\xff\x0a\xfe\x08\xfe\x7d\xfe\x7c\xfe\x38\xfe\x2c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x90\xfe\x89\xfe\xa5\xff\x71\xfe\x75\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x3c\xff\x00\x00\xa8\xff\xe9\xfd\xef\xfd\xf8\xfe\x9d\xff\xf7\xfe\xf3\xfe\x00\x00\xd9\xff\xd9\xff\x9f\xff\x00\x00\x00\x00\x00\x00\x01\xff\x09\xff\x00\x00\x10\xff\x0d\xff\x08\xff\x00\x00\x00\x00\x34\xff\x00\x00\x00\x00\x00\x00\x0e\xff\x80\xff\x73\xff\x00\x00\x23\xfe\x00\x00\x00\x00\xcf\xfe\x96\xff\x00\x00\x00\x00\x00\x00\xd9\xff\xd9\xff\x22\xff\x22\xff\x21\xff\xda\xfe\x00\x00\x00\x00\x00\x00\xda\xff\x05\xfe\x00\x00\xda\xff\x8a\xff\xa1\xff\x00\x00\x7c\xff\x62\xff\x00\x00\x00\x00\x5f\xff\x5d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xd3\xff\xf3\xff\x00\x00\xe0\xff\xd9\xff\xc9\xff\xde\xff\xc6\xff\xe1\xff\xc4\xff\x00\x00\xda\xff\xdd\xff\x71\xfe\xf0\xff\x00\x00\xd3\xff\xd1\xff\xd0\xff\xab\xfd\xcf\xff\xd4\xff\x00\x00\xe6\xff\xe4\xff\xe3\xff\x00\x00\x00\x00\x5e\xff\x60\xff\x7b\xff\x78\xff\x88\xff\x04\xfe\x00\x00\x02\xfe\xdd\xfe\xde\xfe\x00\x00\xd5\xfe\xd9\xff\xd8\xfe\xd6\xfe\xd7\xfe\xcc\xfe\x8f\xff\x00\x00\x1c\xff\x1e\xff\xe6\xfe\x00\x00\x00\x00\x6a\xff\x00\x00\xf8\xfd\xc7\xfe\x25\xfe\x13\xff\x00\x00\x00\xff\x43\xff\x00\x00\x00\x00\x00\x00\x00\x00\x04\xff\x05\xff\x00\x00\x00\x00\x09\xff\x11\xff\x00\x00\x00\x00\x00\x00\x0f\xff\xf0\xfe\xed\xfe\x00\x00\x00\x00\x00\x00\xf4\xfe\x00\x00\xf6\xfe\x9c\xff\x00\x00\x00\x00\xb6\xfe\x21\xfe\x22\xfe\xd9\xff\x1e\xfe\x00\x00\x3e\xfe\x00\x00\x27\xfe\x32\xfe\x30\xfe\x00\x00\x00\x00\x00\x00\x36\xfe\x2b\xfe\x29\xfe\x2a\xfe\x00\x00\xce\xfe\x1b\xfe\x19\xfe\x00\x00\x00\x00\xda\xff\x20\xfe\x00\x00\x24\xff\xf5\xfe\x1a\xff\x1b\xff\xd9\xff\x16\xff\x00\x00\x00\x00\x00\x00\x07\xff\x00\x00\x00\x00\x03\xff\x46\xff\x0c\xff\x00\x00\x00\x00\xfd\xfe\x0b\xff\x33\xff\x00\x00\x6b\xff\xe9\xfe\xea\xfe\xe3\xfe\xd9\xff\xe4\xfe\xe2\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\xdb\xfe\xec\xfe\x00\x00\x65\xff\xcb\xff\x00\x00\x00\x00\xd4\xff\xd5\xff\x00\x00\xca\xff\xdf\xff\xc7\xff\xc2\xff\xc5\xff\x00\x00\xc3\xff\x00\x00\xd2\xff\xd6\xff\x00\x00\xb1\xff\xb0\xff\xaf\xff\xcd\xff\x00\x00\x00\x00\xf8\xfe\x19\xff\xd9\xfe\xcd\xfe\x00\x00\x00\x00\x47\xff\xec\xfe\xec\xfe\xda\xff\xe7\xfe\xff\xfe\x0a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\x18\xff\x00\x00\x1f\xfe\x1c\xfe\x00\x00\x1a\xfe\x1d\xfe\x00\x00\x00\x00\x28\xfe\x76\xfe\x00\x00\x00\x00\x17\xff\x15\xff\x06\xff\x02\xff\xfb\xfe\xfc\xfe\x00\x00\x00\x00\xfe\xfe\xe5\xfe\xdf\xfe\xe1\xfe\x00\x00\xd4\xfe\xf8\xfe\xd3\xfe\x5c\xff\xce\xff\xcc\xff\x00\x00\x00\x00\xc0\xff\xbe\xff\x00\x00\xf1\xff\xb2\xff\xd2\xfe\xe0\xfe\x00\x00\xfa\xfe\x00\x00\x18\xfe\xac\xfe\x00\x00\xc1\xff\xc8\xff\xbf\xff\x00\x00\xbb\xff\xd3\xff\xf9\xfe\x00\x00\xd3\xff\xb8\xff\xb7\xff\xac\xfd\xb6\xff\x00\x00\x00\x00\xd4\xff\xbc\xff\xb9\xff\xbd\xff\x00\x00\xb4\xff\x00\x00\xb5\xff\xb3\xff"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x00\x00\x04\x00\x04\x00\x02\x00\x04\x00\x04\x00\x0b\x00\x11\x00\x12\x00\x13\x00\x2d\x00\x5c\x00\x07\x00\x11\x00\x36\x00\x32\x00\x0d\x00\x0e\x00\x2d\x00\x33\x00\x6b\x00\x07\x00\x1c\x00\x32\x00\x2d\x00\x1d\x00\x1e\x00\x2d\x00\x24\x00\x32\x00\x1c\x00\x36\x00\x32\x00\x3b\x00\x3c\x00\x13\x00\x0d\x00\x0e\x00\xa4\x00\x1c\x00\x5b\x00\x5c\x00\x8e\x00\x0c\x00\xac\x00\x2a\x00\x1c\x00\x1c\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x16\x00\x00\x00\x22\x00\xac\x00\x0d\x00\x0e\x00\x09\x00\x5d\x00\x0b\x00\xac\x00\x6f\x00\xb7\x00\x49\x00\x2a\x00\x4b\x00\x0d\x00\x0e\x00\x11\x00\x66\x00\x67\x00\x54\x00\x55\x00\x0d\x00\x0e\x00\x58\x00\x6f\x00\xc6\x00\x30\x00\x09\x00\x3b\x00\x3c\x00\xd3\x00\x1f\x00\xd3\x00\x0d\x00\x0e\x00\x89\x00\x28\x00\x42\x00\x43\x00\x0d\x00\x0e\x00\xd3\x00\x47\x00\xc4\x00\x49\x00\x4a\x00\x4b\x00\xd3\x00\x51\x00\x6f\x00\xcb\x00\xcc\x00\xcd\x00\xbb\x00\xcf\x00\x25\x00\xd1\x00\x1e\x00\x1a\x00\x53\x00\x17\x00\xc9\x00\xca\x00\x17\x00\x1f\x00\x20\x00\xd5\x00\xc9\x00\xca\x00\x14\x00\x15\x00\x22\x00\x1f\x00\x20\x00\x0d\x00\x0e\x00\x1e\x00\x88\x00\x65\x00\x2f\x00\x22\x00\x29\x00\x21\x00\xbb\x00\x23\x00\x88\x00\x25\x00\x26\x00\x27\x00\x28\x00\xb7\x00\x3b\x00\x15\x00\x2c\x00\x88\x00\x2e\x00\x2f\x00\xc9\x00\xca\x00\xb8\x00\x76\x00\x88\x00\x88\x00\x71\x00\x21\x00\xc6\x00\x23\x00\xb7\x00\x25\x00\x26\x00\x27\x00\x28\x00\xc5\x00\xc6\x00\xc7\x00\x2c\x00\x5a\x00\x2e\x00\x2f\x00\xc6\x00\xc7\x00\xb8\x00\xc6\x00\xd3\x00\xbb\x00\xb6\x00\x76\x00\xbc\x00\xb2\x00\xba\x00\xbf\x00\xd3\x00\xc1\x00\x71\x00\xc5\x00\xc6\x00\xc7\x00\xd3\x00\xc9\x00\xca\x00\xd3\x00\xc6\x00\xc7\x00\xcc\x00\x69\x00\xca\x00\xcf\x00\xb8\x00\xb2\x00\xa5\x00\xbb\x00\x20\x00\xd7\x00\xd3\x00\xca\x00\xd3\x00\xd3\x00\xd6\x00\xd3\x00\xd3\x00\xc5\x00\xc6\x00\xc7\x00\xca\x00\xc9\x00\xca\x00\xa5\x00\xc6\x00\xc7\x00\xc6\x00\xc7\x00\x7a\x00\xc9\x00\xca\x00\xc6\x00\xc7\x00\x0d\x00\x0e\x00\xd7\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x33\x00\xd8\x00\x8b\x00\x8c\x00\x8d\x00\x43\x00\xd8\x00\x7a\x00\x5a\x00\x47\x00\x93\x00\x49\x00\x4a\x00\x4b\x00\x19\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x53\x00\xb6\x00\x8b\x00\x8c\x00\x8d\x00\xba\x00\x22\x00\xb6\x00\x59\x00\x33\x00\x93\x00\xba\x00\x22\x00\x29\x00\x76\x00\xb6\x00\x5d\x00\xc6\x00\xc7\x00\xba\x00\x67\x00\xca\x00\xb5\x00\xc6\x00\xc7\x00\xb8\x00\xb9\x00\xca\x00\xbb\x00\x22\x00\x67\x00\xc6\x00\xc7\x00\xd6\x00\x6f\x00\xca\x00\x3a\x00\x16\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\x5a\x00\x17\x00\xb8\x00\xb9\x00\x27\x00\xbb\x00\xd2\x00\x6f\x00\x3a\x00\x05\x00\x06\x00\x2e\x00\x22\x00\x08\x00\x09\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x33\x00\x34\x00\x05\x00\x06\x00\x21\x00\x16\x00\x23\x00\xd2\x00\x25\x00\x26\x00\x27\x00\x28\x00\x08\x00\xb6\x00\x0a\x00\x2c\x00\xc4\x00\x2e\x00\x2f\x00\x16\x00\x08\x00\x25\x00\x26\x00\xcb\x00\xcc\x00\x1c\x00\x21\x00\xb6\x00\x23\x00\xc6\x00\xc7\x00\xba\x00\x27\x00\x28\x00\x32\x00\x33\x00\x34\x00\x2c\x00\x6f\x00\x2e\x00\x2f\x00\x29\x00\x26\x00\xc6\x00\xc7\x00\xb8\x00\x17\x00\xca\x00\xc6\x00\xc7\x00\x26\x00\xc9\x00\xca\x00\x69\x00\x32\x00\x33\x00\x34\x00\x22\x00\xc5\x00\xc6\x00\xc7\x00\x17\x00\x32\x00\x33\x00\x34\x00\xb4\x00\xd8\x00\x43\x00\x44\x00\x45\x00\xb9\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\xb8\x00\xd5\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x5d\x00\x46\x00\x47\x00\xc8\x00\x49\x00\x4a\x00\x4b\x00\xc5\x00\xc6\x00\xc7\x00\x8e\x00\x7a\x00\x90\x00\xc6\x00\xc7\x00\x22\x00\xc9\x00\xca\x00\x6f\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xbf\x00\x2e\x00\x8b\x00\x8c\x00\x8d\x00\xd8\x00\x65\x00\x7a\x00\x0d\x00\x0e\x00\x93\x00\x05\x00\x06\x00\xcc\x00\x19\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x18\x00\x22\x00\x8b\x00\x8c\x00\x8d\x00\x21\x00\x16\x00\x23\x00\x4a\x00\x4b\x00\x93\x00\x27\x00\x28\x00\xc6\x00\xc7\x00\x19\x00\x2c\x00\xaa\x00\x2e\x00\x2f\x00\x22\x00\x17\x00\xb5\x00\x17\x00\x22\x00\xb8\x00\xb9\x00\x29\x00\xbb\x00\x43\x00\x7b\x00\xd8\x00\x22\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xc4\x00\xcc\x00\xb8\x00\xb9\x00\xcf\x00\xbb\x00\xd2\x00\xcb\x00\xcc\x00\xcd\x00\xb9\x00\xcf\x00\x19\x00\xd1\x00\x22\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x22\x00\x2a\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xd2\x00\xbc\x00\xb0\x00\xb1\x00\xbf\x00\x21\x00\xc1\x00\x23\x00\xc6\x00\xc7\x00\xb8\x00\xc9\x00\xca\x00\xd8\x00\xd4\x00\x2b\x00\x2c\x00\xcc\x00\x2e\x00\x2f\x00\xcf\x00\x7a\x00\x11\x00\xc5\x00\xc6\x00\xc7\x00\xd8\x00\x19\x00\xd4\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x22\x00\x22\x00\x8b\x00\x8c\x00\x8d\x00\x21\x00\x27\x00\x23\x00\x3f\x00\x40\x00\x93\x00\x2c\x00\x30\x00\x31\x00\xc6\x00\xc7\x00\x2c\x00\xca\x00\x2e\x00\x2f\x00\x19\x00\xc6\x00\xc7\x00\xc6\x00\xc7\x00\xca\x00\xc9\x00\xca\x00\x94\x00\x22\x00\x1e\x00\x43\x00\xd8\x00\x45\x00\x22\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x03\x00\xd8\x00\x4e\x00\x4f\x00\xb5\x00\x08\x00\x09\x00\xb8\x00\xb9\x00\x01\x00\xbb\x00\xc6\x00\xc7\x00\xd5\x00\xc9\x00\xca\x00\x08\x00\x09\x00\x7a\x00\x01\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x08\x00\x09\x00\x84\x00\xd8\x00\x86\x00\x16\x00\x88\x00\xd2\x00\xd4\x00\x8b\x00\x8c\x00\x8d\x00\x21\x00\xcf\x00\x23\x00\x40\x00\x41\x00\x93\x00\x0d\x00\x0e\x00\x72\x00\x73\x00\x74\x00\x2c\x00\x69\x00\x2e\x00\x2f\x00\x47\x00\x7a\x00\x49\x00\x4a\x00\x4b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xd4\x00\xcd\x00\x84\x00\xcf\x00\x86\x00\xd1\x00\x88\x00\x0d\x00\x0e\x00\x8b\x00\x8c\x00\x8d\x00\x59\x00\xb3\x00\xb4\x00\xb5\x00\x43\x00\x93\x00\xb8\x00\xb9\x00\x47\x00\xbb\x00\x49\x00\x4a\x00\x4b\x00\xb6\x00\x26\x00\x94\x00\x28\x00\xba\x00\x69\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xd3\x00\x32\x00\x33\x00\x34\x00\xc6\x00\xc7\x00\x69\x00\xd2\x00\xca\x00\x52\x00\xb9\x00\xc5\x00\xc6\x00\xc7\x00\xb5\x00\xc9\x00\xca\x00\xb8\x00\xb9\x00\xcf\x00\xbb\x00\x73\x00\x74\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x7a\x00\xd3\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x03\x00\x21\x00\x84\x00\x23\x00\x86\x00\xd8\x00\x88\x00\xd2\x00\xd4\x00\x8b\x00\x8c\x00\x8d\x00\x2c\x00\x99\x00\x2e\x00\x2f\x00\x7c\x00\x93\x00\x0d\x00\x0e\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xb6\x00\xc5\x00\xc6\x00\xc7\x00\xba\x00\xc9\x00\xca\x00\x93\x00\x28\x00\x95\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x2f\x00\xc6\x00\xc7\x00\x50\x00\x0a\x00\xca\x00\xc6\x00\xc7\x00\x38\x00\xc9\x00\xca\x00\x6f\x00\xb5\x00\x43\x00\x3a\x00\xb8\x00\xb9\x00\x47\x00\xbb\x00\x49\x00\x4a\x00\x4b\x00\x54\x00\x55\x00\xd8\x00\x57\x00\x58\x00\xd4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xd4\x00\xc6\x00\xc7\x00\x6f\x00\xc9\x00\xca\x00\xd3\x00\xd2\x00\xbd\x00\x70\x00\x8e\x00\xc0\x00\x90\x00\xc2\x00\x8e\x00\xc4\x00\x90\x00\x7a\x00\x93\x00\xd8\x00\x95\x00\x35\x00\xcb\x00\xcc\x00\xcd\x00\x7b\x00\xcf\x00\x84\x00\xd1\x00\x86\x00\x2c\x00\x88\x00\x2e\x00\x7f\x00\x8b\x00\x8c\x00\x8d\x00\x7b\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x93\x00\x28\x00\x30\x00\x31\x00\x59\x00\x08\x00\x09\x00\x69\x00\x2f\x00\x84\x00\x28\x00\x86\x00\x2a\x00\x88\x00\xc6\x00\xc7\x00\x8b\x00\x8c\x00\x8d\x00\xd4\x00\x28\x00\x43\x00\x2a\x00\x45\x00\x93\x00\x47\x00\xb6\x00\x49\x00\x4a\x00\x4b\x00\xba\x00\xae\x00\x4e\x00\x4f\x00\xb5\x00\x26\x00\x8e\x00\xb8\x00\xb9\x00\x2c\x00\xbb\x00\x2e\x00\xc6\x00\xc7\x00\x54\x00\x55\x00\xca\x00\x32\x00\x33\x00\x34\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x99\x00\x28\x00\xb5\x00\x2a\x00\xd4\x00\xb8\x00\xb9\x00\xd2\x00\xbb\x00\x1a\x00\x1b\x00\x1c\x00\xc6\x00\xc7\x00\xd4\x00\xc9\x00\xca\x00\x34\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x56\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\xd8\x00\xd2\x00\x75\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x84\x00\x28\x00\x86\x00\x2a\x00\x88\x00\x5f\x00\x60\x00\x8b\x00\x8c\x00\x8d\x00\x43\x00\x28\x00\x45\x00\x2a\x00\x47\x00\x93\x00\x49\x00\x4a\x00\x4b\x00\xb1\x00\x34\x00\x4e\x00\x4f\x00\x96\x00\x97\x00\x98\x00\xb8\x00\x39\x00\x42\x00\x43\x00\xb8\x00\x45\x00\x28\x00\x47\x00\x2a\x00\x49\x00\x4a\x00\x4b\x00\xca\x00\xc5\x00\xc6\x00\xc7\x00\xd5\x00\xc5\x00\xc6\x00\xc7\x00\xb9\x00\x39\x00\x2a\x00\xb5\x00\x2c\x00\x39\x00\xb8\x00\xb9\x00\x22\x00\xbb\x00\x96\x00\x97\x00\x98\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x39\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\xd3\x00\xd8\x00\xd2\x00\x47\x00\x94\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\xa8\x00\xa9\x00\xaa\x00\x47\x00\x8e\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x28\x00\xb8\x00\x2a\x00\x47\x00\xbb\x00\x49\x00\x4a\x00\x4b\x00\x01\x00\x02\x00\x6d\x00\x6e\x00\x05\x00\x06\x00\xc5\x00\xc6\x00\xc7\x00\x52\x00\xc9\x00\xca\x00\x17\x00\xb6\x00\x43\x00\x17\x00\x45\x00\xba\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x16\x00\xb9\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xc6\x00\xc7\x00\x6d\x00\x6e\x00\xca\x00\x6c\x00\x6d\x00\x6e\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x28\x00\x47\x00\x2a\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x0c\x00\x0d\x00\x0e\x00\x43\x00\x28\x00\x45\x00\x2a\x00\x47\x00\x16\x00\x49\x00\x4a\x00\x4b\x00\x33\x00\xd8\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x68\x00\x0d\x00\x0e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x8e\x00\x0d\x00\x0e\x00\xc6\x00\xc7\x00\xb8\x00\xc9\x00\xca\x00\x0c\x00\x0d\x00\x0e\x00\x65\x00\x59\x00\xc6\x00\xc7\x00\x4d\x00\xc9\x00\xca\x00\xc5\x00\xc6\x00\xc7\x00\xd8\x00\x5f\x00\xc6\x00\xc7\x00\xb8\x00\xc9\x00\xca\x00\x97\x00\x98\x00\x78\x00\xd8\x00\xb8\x00\xc6\x00\xc7\x00\x88\x00\xc9\x00\xca\x00\xc5\x00\xc6\x00\xc7\x00\xd8\x00\x28\x00\xb9\x00\x2a\x00\xc5\x00\xc6\x00\xc7\x00\x0f\x00\x10\x00\x8e\x00\xd8\x00\x4d\x00\x28\x00\xc4\x00\x2a\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x2a\x00\xcf\x00\x2c\x00\xd1\x00\x88\x00\x40\x00\x41\x00\xb9\x00\x0d\x00\x0e\x00\xd8\x00\x0c\x00\xbd\x00\x05\x00\x06\x00\xc0\x00\x1c\x00\xc2\x00\x29\x00\xc4\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x77\x00\xcb\x00\xcc\x00\xcd\x00\xb9\x00\xcf\x00\x2a\x00\xd1\x00\x47\x00\x2a\x00\x49\x00\x4a\x00\x4b\x00\xd8\x00\x5f\x00\xc4\x00\x17\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\xcf\x00\x45\x00\xd1\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x0f\x00\xd8\x00\x4e\x00\x4f\x00\x1c\x00\x51\x00\x5e\x00\x5f\x00\x60\x00\x17\x00\x43\x00\x2a\x00\x45\x00\x1d\x00\x47\x00\x33\x00\x49\x00\x4a\x00\x4b\x00\x0d\x00\x0e\x00\x4e\x00\x4f\x00\x33\x00\x51\x00\x6c\x00\x6d\x00\x6e\x00\x29\x00\x43\x00\x6a\x00\x45\x00\x28\x00\x47\x00\x2c\x00\x49\x00\x4a\x00\x4b\x00\x1c\x00\x4d\x00\x4e\x00\x4f\x00\x77\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x76\x00\x45\x00\x50\x00\x47\x00\x0c\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\x6c\x00\x6d\x00\x6e\x00\xb6\x00\x0d\x00\x0e\x00\x43\x00\xba\x00\x45\x00\x17\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\xc6\x00\xc7\x00\x08\x00\x09\x00\xca\x00\x8e\x00\x43\x00\x1e\x00\x45\x00\x05\x00\x47\x00\x88\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x4d\x00\x4e\x00\x4f\x00\x37\x00\x38\x00\xc6\x00\xc7\x00\x88\x00\xc9\x00\xca\x00\x43\x00\x33\x00\x45\x00\xb9\x00\x47\x00\x1e\x00\x49\x00\x4a\x00\x4b\x00\x2a\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\x05\x00\x06\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x29\x00\x47\x00\x16\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x17\x00\x47\x00\x1c\x00\x49\x00\x4a\x00\x4b\x00\x78\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x88\x00\x47\x00\x7d\x00\x49\x00\x4a\x00\x4b\x00\x77\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x88\x00\x47\x00\x88\x00\x49\x00\x4a\x00\x4b\x00\x2a\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x26\x00\x47\x00\x1c\x00\x49\x00\x4a\x00\x4b\x00\x88\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x05\x00\x06\x00\xb9\x00\x29\x00\x2a\x00\x47\x00\x1e\x00\x49\x00\x4a\x00\x4b\x00\x7d\x00\x7e\x00\x7f\x00\xd8\x00\x29\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\x17\x00\x45\x00\xb9\x00\x47\x00\x68\x00\x49\x00\x4a\x00\x4b\x00\x63\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\x05\x00\x06\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x88\x00\x47\x00\x1d\x00\x49\x00\x4a\x00\x4b\x00\x1d\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x17\x00\x47\x00\x5f\x00\x49\x00\x4a\x00\x4b\x00\x32\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x1e\x00\x47\x00\x5a\x00\x49\x00\x4a\x00\x4b\x00\x2c\x00\x4d\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x05\x00\x47\x00\x2c\x00\x49\x00\x4a\x00\x4b\x00\x4d\x00\x4e\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\x22\x00\x45\x00\x42\x00\x47\x00\x1c\x00\x49\x00\x4a\x00\x4b\x00\x03\x00\x04\x00\x4e\x00\x4f\x00\xd8\x00\x61\x00\xc6\x00\xc7\x00\x2a\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x0c\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x4d\x00\x4e\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\x17\x00\x45\x00\xb9\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x82\x00\x83\x00\x4e\x00\x4f\x00\xd8\x00\x57\x00\x58\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x25\x00\x47\x00\x77\x00\x49\x00\x4a\x00\x4b\x00\x29\x00\x2a\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x25\x00\x47\x00\x5f\x00\x49\x00\x4a\x00\x4b\x00\x05\x00\x06\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x1d\x00\x47\x00\x5f\x00\x49\x00\x4a\x00\x4b\x00\x2e\x00\x2c\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x1d\x00\x47\x00\x2d\x00\x49\x00\x4a\x00\x4b\x00\x1d\x00\x29\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x1d\x00\x43\x00\xb9\x00\x45\x00\x22\x00\x47\x00\x2e\x00\x49\x00\x4a\x00\x4b\x00\x7d\x00\x7e\x00\x7f\x00\xd8\x00\x22\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x2a\x00\x47\x00\x88\x00\x49\x00\x4a\x00\x4b\x00\x21\x00\x0f\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\x0f\x00\x45\x00\xb9\x00\x47\x00\x16\x00\x49\x00\x4a\x00\x4b\x00\x49\x00\x1e\x00\x4e\x00\x4f\x00\xd8\x00\x4f\x00\x17\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x17\x00\x47\x00\x0f\x00\x49\x00\x4a\x00\x4b\x00\x29\x00\x0c\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x43\x00\xb9\x00\x45\x00\x63\x00\x47\x00\x21\x00\x49\x00\x4a\x00\x4b\x00\x88\x00\x29\x00\x4e\x00\x4f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x88\x00\xb9\x00\x43\x00\x44\x00\x45\x00\x88\x00\x47\x00\x2a\x00\x49\x00\x4a\x00\x4b\x00\x1e\x00\x1e\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x22\x00\x1d\x00\xb9\x00\x43\x00\x17\x00\x45\x00\x29\x00\x47\x00\x77\x00\x49\x00\x4a\x00\x4b\x00\x77\x00\xd8\x00\x2c\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x77\x00\xb9\x00\x25\x00\x63\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x96\x00\x97\x00\x98\x00\x77\x00\x5f\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x22\x00\xb9\x00\x46\x00\x47\x00\x25\x00\x49\x00\x4a\x00\x4b\x00\x96\x00\x97\x00\x98\x00\x4f\x00\x1c\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x54\x00\x55\x00\x56\x00\xb9\x00\x28\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x1e\x00\x61\x00\x62\x00\x63\x00\xd8\x00\x65\x00\x1d\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x4f\x00\xb9\x00\x46\x00\x47\x00\x25\x00\x49\x00\x4a\x00\x4b\x00\x85\x00\x86\x00\x87\x00\x25\x00\x17\x00\xd8\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x1b\x00\x2a\x00\x22\x00\xb9\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x05\x00\x1c\x00\x61\x00\x62\x00\x63\x00\xd8\x00\x65\x00\x88\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x17\x00\x22\x00\xb9\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x17\x00\x17\x00\x17\x00\x64\x00\x17\x00\xd8\x00\x17\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x17\x00\x21\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\xc6\x00\xc7\x00\xd8\x00\xc9\x00\xca\x00\x01\x00\x2c\x00\x42\x00\xbb\x00\x3e\x00\x3f\x00\x40\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x21\x00\xd8\x00\xc6\x00\xc7\x00\x2e\x00\xc9\x00\xca\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x28\x00\x42\x00\x47\x00\x74\x00\xc0\x00\x71\x00\x68\x00\x2e\x00\xc4\x00\xd8\x00\xc6\x00\xc7\x00\x4f\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x88\x00\x88\x00\x0c\x00\xbb\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x17\x00\x17\x00\xd8\x00\xd9\x00\xda\x00\xc6\x00\xc7\x00\x22\x00\xc9\x00\xca\x00\x17\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x21\x00\x2c\x00\x68\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xd8\x00\xc6\x00\xc7\x00\x50\x00\xc9\x00\xca\x00\x77\x00\x2a\x00\x29\x00\x20\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x22\x00\x0f\x00\xd8\x00\x05\x00\xc6\x00\xc7\x00\x1d\x00\xc9\x00\xca\x00\x6f\x00\x88\x00\x65\x00\x89\x00\x20\x00\x0f\x00\x6c\x00\x1d\x00\x16\x00\x62\x00\x89\x00\x0c\x00\x29\x00\xd8\x00\xc6\x00\xc7\x00\x89\x00\xc9\x00\xca\x00\xc6\x00\xc7\x00\x78\x00\xc9\x00\xca\x00\x0f\x00\x0f\x00\xb6\x00\x0f\x00\x89\x00\x1d\x00\xba\x00\x1d\x00\xd8\x00\x1d\x00\x1d\x00\xc6\x00\xc7\x00\xd8\x00\xc9\x00\xca\x00\x01\x00\x2d\x00\xc6\x00\xc7\x00\x89\x00\x00\x00\xca\x00\xc6\x00\xc7\x00\xff\xff\xc9\x00\xca\x00\x2d\x00\xd8\x00\x0f\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xd8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc6\x00\xc7\x00\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xc6\x00\xc7\x00\xd8\x00\xc9\x00\xca\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xd8\x00\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\x2b\x00\xff\xff\x57\x00\x58\x00\x59\x00\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\x65\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\xff\xff\x70\x00\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\xff\xff\xff\xff\xff\xff\x87\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\x20\x00\xc4\x00\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xcb\x00\xcc\x00\xcd\x00\x2b\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\xff\xff\x70\x00\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\xff\xff\xff\xff\xff\xff\x87\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x01\x00\x70\x00\xff\xff\x72\x00\x05\x00\x06\x00\x75\x00\xff\xff\x09\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x16\x00\xff\xff\x18\x00\x87\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x01\x00\x20\x00\x03\x00\x04\x00\x05\x00\x06\x00\x25\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\xff\xff\x33\x00\x16\x00\xff\xff\x18\x00\x25\x00\x26\x00\xff\xff\x28\x00\x01\x00\x16\x00\xff\xff\x20\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x32\x00\x33\x00\x34\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x33\x00\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x78\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x63\x00\x01\x00\x65\x00\x84\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x6f\x00\x78\x00\x16\x00\x01\x00\x18\x00\xff\xff\xff\xff\x05\x00\x06\x00\x78\x00\x65\x00\xff\xff\x20\x00\x84\x00\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\x06\x00\x78\x00\xff\xff\x33\x00\x17\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\x22\x00\x16\x00\xff\xff\x18\x00\x26\x00\x7c\x00\x28\x00\xff\xff\xff\xff\xff\xff\x33\x00\x20\x00\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x84\x00\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xc4\x00\xff\xff\x78\x00\x65\x00\xff\xff\xff\xff\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xcf\x00\xff\xff\xd1\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x84\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\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\x28\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x01\x00\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x16\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x53\x00\x23\x00\x24\x00\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\x78\x00\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x25\x00\x26\x00\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\x16\x00\x17\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7f\x00\x80\x00\x81\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x65\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\x78\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x16\x00\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\x1e\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x16\x00\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x16\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x26\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\x01\x00\x02\x00\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\x16\x00\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x1e\x00\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x27\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x65\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\x78\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x16\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x26\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\x16\x00\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x30\x00\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x65\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x6e\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x25\x00\x26\x00\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x01\x00\x2e\x00\xff\xff\x30\x00\x05\x00\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x16\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x78\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x07\x00\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x78\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\x28\x00\x63\x00\xff\xff\x65\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x78\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x22\x00\xff\xff\x28\x00\x25\x00\x26\x00\x65\x00\x28\x00\x29\x00\x2e\x00\x01\x00\x30\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x19\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x78\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x01\x00\x65\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x01\x00\x6c\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x01\x00\x18\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x78\x00\x20\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x01\x00\xff\xff\xff\xff\x65\x00\x05\x00\x06\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x16\x00\x78\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x65\x00\x20\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\x78\x00\xff\xff\x65\x00\x05\x00\x06\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x78\x00\x18\x00\x20\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x31\x00\x01\x00\xff\xff\x78\x00\xff\xff\x05\x00\x06\x00\x31\x00\x62\x00\xff\xff\xff\xff\x65\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x20\x00\x16\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\x01\x00\x65\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x65\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x16\x00\x20\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x65\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x78\x00\x18\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x20\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x01\x00\x65\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x65\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\x78\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\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\x00\x02\x00\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x16\x00\xff\xff\xff\xff\xff\xff\x65\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x6f\x00\xff\xff\x78\x00\xff\xff\x01\x00\x16\x00\x75\x00\xff\xff\x05\x00\x78\x00\x65\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\xff\xff\xff\xff\x78\x00\xff\xff\x01\x00\x16\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x16\x00\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x16\x00\xff\xff\x78\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x65\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x78\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x65\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x22\x00\xff\xff\xff\xff\x25\x00\x26\x00\xff\xff\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x9f\x00\xa0\x00\xa1\x00\xff\xff\xa3\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\xff\xff\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xad\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xad\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xad\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xad\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x00\x9d\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xbe\x00\xff\xff\xc0\x00\xff\xff\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xce\x00\xff\xff\xd0\x00\xd1\x00\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xa6\x00\xa7\x00\xff\xff\x93\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xa7\x00\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\x91\x00\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\x91\x00\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xd2\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xd2\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\x88\x00\xff\xff\xd2\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xd2\x00\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x96\x00\x97\x00\x98\x00\xff\xff\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\x93\x00\xff\xff\xff\xff\x96\x00\x97\x00\x98\x00\xff\xff\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\x93\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\x93\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\x93\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xff\xff\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x00\xff\xff\xd2\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\xff\xff\xff\xff\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\x0c\x00\x09\x00\x0b\x00\x95\x00\x09\x00\x96\x00\x2f\x02\x43\x03\x44\x03\x45\x03\xb9\x00\x01\x04\xd8\x02\x2a\x04\x14\x03\x10\x03\x84\x01\x0b\x02\xb9\x00\xb4\x03\xf7\x02\x82\x01\x5a\x02\x13\x03\xb9\x00\x2b\x04\x2c\x04\xb9\x00\xe7\x01\xba\x00\x5a\x02\x64\x02\x05\x01\x50\x03\x2c\x03\xd8\x03\x84\x01\x0b\x02\x9f\x02\x1e\x02\xa9\x03\xaa\x03\xea\x00\x1a\x02\xfe\x00\x0c\x02\x20\x02\x20\x02\x84\x01\x1d\x03\x84\x01\xea\x02\xba\xff\x89\x01\xaf\x01\x04\x01\x84\x01\x65\x03\xd1\x00\xe1\x03\xd3\x00\x07\x01\x9d\x00\x16\x03\x9b\x00\x0e\x02\x9c\x00\x84\x01\xea\x02\x31\x04\xb5\x03\xb6\x03\x5e\x02\x5f\x02\x84\x01\x1d\x03\x64\x03\xe2\x03\x66\x02\x1b\x02\xd1\x00\x2b\x03\x2c\x03\xff\x00\x8a\x01\xa0\x02\x84\x01\x65\x03\xf5\xff\xd7\x00\xba\x03\x11\x02\x84\x01\x81\x03\xff\x00\xb6\x00\xeb\x00\x64\x00\x65\x00\x66\x00\xff\x00\xea\x02\x9d\x00\xca\x00\xcb\x00\xec\x00\xab\x03\xcd\x00\x75\x03\xce\x00\x34\x04\x6e\x01\xe3\x01\x3b\x04\xf8\x02\x25\x00\xde\x01\x36\x04\xdb\x03\x23\x04\x24\x00\x25\x00\x38\x03\x39\x03\x15\x04\xda\x03\xdb\x03\xea\x03\xeb\x03\xee\x03\xd8\x02\x28\x04\x6f\x01\xef\x03\xdf\x01\x72\x00\xab\x03\x73\x00\xd4\x02\x3a\x03\xb6\x01\xb7\x01\x75\x00\x65\x02\x70\x01\xd0\x03\x76\x00\x1f\x02\x77\x00\x78\x00\x24\x00\x25\x00\xf6\x01\x1e\x03\x21\x02\x24\x02\x66\x03\x72\x00\x66\x02\x73\x00\x65\x02\xd1\x03\xb6\x01\xb7\x01\x75\x00\x20\x00\x21\x00\x22\x00\x76\x00\x82\x03\x77\x00\x78\x00\x21\x00\x2d\x03\x46\x03\x66\x02\xbb\x00\x47\x03\x2d\x04\x1f\x03\xe8\x01\x0d\x02\x2e\x04\xe9\x01\xbb\x00\xea\x01\x67\x03\x20\x00\x21\x00\x22\x00\xbb\x00\x24\x00\x25\x00\xbb\x00\x21\x00\xa1\x00\xeb\x01\x1b\x04\xa2\x00\xec\x01\x46\x03\x0f\x02\xeb\x02\x47\x03\x1a\x04\x48\x03\x30\x02\x83\x01\x0a\x00\x0a\x00\x2f\x04\x0a\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x83\x01\x24\x00\x25\x00\xec\x02\x21\x00\x2d\x03\x21\x00\x6b\x00\x79\x00\x6c\x00\x25\x00\x21\x00\x6b\x00\x84\x01\x81\x03\x48\x03\x7a\x00\x10\x00\x7b\x00\x12\x00\x13\x00\x14\x00\x15\x00\xb4\x03\x6d\x00\x16\x00\x17\x00\x18\x00\xd4\x01\xe4\x01\x79\x00\x96\x03\xb6\x00\x19\x00\x64\x00\x65\x00\x66\x00\x17\x04\x7a\x00\x10\x00\x7b\x00\x12\x00\x13\x00\x14\x00\x15\x00\xc3\x00\x2d\x04\x16\x00\x17\x00\x18\x00\x2e\x04\x78\x02\xdc\x03\x0f\x04\xf5\x01\x19\x00\xdd\x03\xe3\x02\xf0\x03\x97\x03\xdc\x03\x88\x02\x21\x00\xa1\x00\xdd\x03\xc4\x00\xa2\x00\x1c\x00\x21\x00\xa1\x00\x1d\x00\x1e\x00\xa2\x00\x1f\x00\xaf\x01\x09\x04\x21\x00\xa1\x00\x2f\x04\x89\x02\xa2\x00\xe4\x02\x82\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x83\x03\x14\x04\x1d\x00\x1e\x00\xde\x02\x1f\x00\x26\x00\x0b\x04\xb0\x01\x2c\x00\x2d\x00\xa6\x01\x15\x04\xd0\x00\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x84\x02\x2c\x00\x2d\x00\x72\x00\xad\x03\x73\x00\x26\x00\xb5\x01\xb6\x01\xb7\x01\x75\x00\xd0\x00\x0e\x03\xd2\x00\x76\x00\xb8\x01\x77\x00\x78\x00\xad\x03\xd0\x00\xee\x01\xd6\x00\xca\x00\xcb\x00\x5a\x02\x72\x00\xdc\x03\x73\x00\x21\x00\xa1\x00\xdd\x03\xe5\x02\x75\x00\xd9\x00\xda\x00\xdb\x00\x76\x00\x0c\x04\x77\x00\x78\x00\x04\x02\xd6\x00\x21\x00\xa1\x00\xf6\x01\xdd\x02\xa2\x00\x21\x00\x6b\x00\xd6\x00\x6c\x00\x25\x00\x10\x04\xd9\x00\xda\x00\xdb\x00\xe7\x00\x20\x00\x21\x00\x22\x00\xcc\x02\xd9\x00\xda\x00\xdb\x00\x55\x03\x6d\x00\x61\x00\x05\x02\x06\x02\x56\x03\x63\x00\xe7\x00\x64\x00\x65\x00\x66\x00\xf6\x01\x16\x04\xe2\x00\x69\x00\x07\x02\xe9\x00\xef\x01\x00\x03\xb2\x03\x23\x00\x64\x00\x65\x00\x66\x00\x20\x00\x21\x00\x22\x00\x9e\x01\x79\x00\xdb\x02\x21\x00\x6b\x00\xe3\x02\xba\x01\x25\x00\xf0\x01\x7a\x00\x10\x00\x7b\x00\x12\x00\x13\x00\x14\x00\x15\x00\x73\x03\x00\x04\x16\x00\x17\x00\x18\x00\xd3\x01\xb3\x03\x79\x00\xf3\x03\xf4\x03\x19\x00\x2c\x00\x2d\x00\xeb\x01\xa7\x01\x7a\x00\x10\x00\x7b\x00\x12\x00\x13\x00\x14\x00\x15\x00\xd5\x03\xa4\x01\x16\x00\x17\x00\x18\x00\x72\x00\xfa\x02\x73\x00\x45\x01\x66\x00\x19\x00\x74\x00\x75\x00\x21\x00\x6b\x00\xe6\x00\x76\x00\xf9\x03\x77\x00\x78\x00\x78\x02\xa1\x01\x1c\x00\xdb\x01\xe7\x00\x1d\x00\x1e\x00\x79\x02\x1f\x00\xd5\x01\xfa\x03\x1c\x03\xe7\x00\xb6\x00\xa4\x01\x64\x00\x65\x00\x66\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\xb8\x01\x26\x02\x1d\x00\x1e\x00\x27\x02\x1f\x00\x26\x00\xca\x00\xcb\x00\x65\x01\x6a\x00\xcd\x00\xe0\x01\xce\x00\xe3\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xa4\x01\x13\x03\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x26\x00\xe8\x01\x91\x01\x92\x01\xe9\x01\x72\x00\xf2\x02\x73\x00\x21\x00\x6b\x00\x93\x01\x6c\x00\x25\x00\x6d\x00\xa7\x03\x53\x02\x54\x02\xeb\x01\x77\x00\x78\x00\xec\x01\x79\x00\xcc\x03\x20\x00\x21\x00\x22\x00\x6d\x00\xe1\x01\xbb\x03\x7a\x00\x10\x00\x7b\x00\x12\x00\x13\x00\x14\x00\x15\x00\xe2\x01\xaa\x01\x16\x00\x17\x00\x18\x00\x72\x00\xab\x01\x73\x00\x3d\x02\xa9\x00\x19\x00\xac\x01\x53\x03\x46\x02\x21\x00\x6b\x00\xbd\x03\x8b\x02\x77\x00\x78\x00\x60\x01\x21\x00\x8a\x02\x21\x00\x6b\x00\x8b\x02\x6c\x00\x25\x00\xcf\x03\xe7\x00\xd1\x02\x61\x00\x8e\x02\x62\x00\xd2\x02\x63\x00\xd3\x03\x64\x00\x65\x00\x66\x00\x97\x00\x46\x01\x47\x02\x69\x00\x1c\x00\x98\x00\x99\x00\x1d\x00\x1e\x00\x80\x01\x1f\x00\x21\x00\x6b\x00\xca\x03\x6c\x00\x25\x00\x7f\x01\x99\x00\x79\x00\x7e\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7f\x01\x99\x00\x55\x02\x6d\x00\x13\x00\x3d\x03\x15\x00\x26\x00\x58\x03\x16\x00\x17\x00\x18\x00\x72\x00\x27\x02\x73\x00\x9d\x00\x81\x01\x19\x00\xa2\x03\xa3\x03\xbe\x03\xbf\x03\xc0\x03\xbd\x03\x87\x03\x77\x00\x78\x00\xaf\x03\x79\x00\x64\x00\x65\x00\x66\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x8b\x03\x65\x01\x55\x02\xcd\x00\x13\x00\xce\x00\x15\x00\xc5\x03\xc6\x03\x16\x00\x17\x00\x18\x00\xf5\x02\x56\x02\x57\x02\x1c\x00\xd6\x01\x19\x00\x1d\x00\x58\x02\xb6\x00\x1f\x00\x64\x00\x65\x00\x66\x00\x9f\x00\xd6\x00\x91\x03\xd7\x00\xa0\x00\xf6\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xfa\x02\xd9\x00\xda\x00\xdb\x00\x21\x00\xa1\x00\xfc\x02\x26\x00\xa2\x00\xff\x02\x6a\x00\xb9\x01\x21\x00\x22\x00\x1c\x00\xba\x01\x25\x00\x1d\x00\x1e\x00\x15\x03\x1f\x00\x0a\x04\xc0\x03\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x79\x00\x18\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x35\x03\x72\x00\x55\x02\x73\x00\x13\x00\x6d\x00\x15\x00\x26\x00\x37\x03\x16\x00\x17\x00\x18\x00\x54\x03\x35\x02\x77\x00\x78\x00\xc5\x00\x19\x00\x3f\x03\x40\x03\xa6\x00\xa7\x00\xa8\x00\xa9\x00\x9f\x00\xf4\x01\x21\x00\x22\x00\xa0\x00\xba\x01\x25\x00\xc0\x01\x5a\x03\xc1\x01\xc3\x01\x4c\x00\xd8\x03\x4d\x00\x4e\x00\x5b\x03\x21\x00\xa1\x00\xc5\x01\x37\x02\xa2\x00\x21\x00\x6b\x00\x3f\x02\x6c\x00\x25\x00\x4d\x02\x1c\x00\xb5\x00\x40\x02\x1d\x00\x1e\x00\xb6\x00\x1f\x00\x64\x00\x65\x00\x66\x00\x5e\x02\x5f\x02\x6d\x00\x60\x02\x61\x02\x4f\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x50\x02\x21\x00\x6b\x00\x5d\x02\x6c\x00\x25\x00\x5a\x02\x26\x00\xc6\x00\x62\x02\x9e\x01\xc7\x00\xca\x02\x23\x03\x9e\x01\xc9\x00\x9f\x01\x79\x00\xc0\x01\x6d\x00\xc1\x01\x69\x02\xca\x00\xcb\x00\xcc\x00\x6d\x02\xcd\x00\x55\x02\xce\x00\x13\x00\xa1\x03\x15\x00\xa2\x03\x75\x02\x16\x00\x17\x00\x18\x00\x76\x02\x5c\x03\x5d\x03\x5e\x03\x5f\x03\x19\x00\x5a\x03\x2a\x03\x46\x02\x84\x02\xd0\x00\xd1\x00\x86\x02\x5b\x03\x60\x03\x41\xfe\x13\x00\x41\xfe\x15\x00\x21\x00\x4f\x03\x16\x00\x17\x00\x18\x00\x97\x02\x53\xfe\x61\x00\x53\xfe\x62\x00\x19\x00\x63\x00\x9f\x00\x64\x00\x65\x00\x66\x00\xa0\x00\x99\x02\x47\x02\x69\x00\x1c\x00\xd6\x00\xe4\x00\x1d\x00\x1e\x00\xa5\x01\x1f\x00\xa6\x01\x21\x00\xa1\x00\x5e\x02\x63\x03\xa2\x00\xd9\x00\xda\x00\xdb\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xbe\x01\x5d\xfe\x1c\x00\x5d\xfe\xb9\x02\x1d\x00\x1e\x00\x26\x00\x1f\x00\x24\x04\x25\x04\x26\x04\x21\x00\x6b\x00\x87\x01\x6c\x00\x25\x00\xfd\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x01\x02\xe3\x03\x5e\x03\x5f\x03\x45\x02\x46\x02\x6d\x00\x26\x00\x09\x02\xaa\x00\xa7\x00\xa8\x00\xa9\x00\x60\x03\x5e\xfe\x13\x00\x5e\xfe\x15\x00\x6d\x03\x7c\x02\x16\x00\x17\x00\x18\x00\x61\x00\x5f\xfe\x62\x00\x5f\xfe\x63\x00\x19\x00\x64\x00\x65\x00\x66\x00\xd9\x02\x00\x02\x47\x02\x69\x00\x15\x04\x0c\x01\x0d\x01\x93\x01\x1c\x02\xe6\x03\xe7\x03\x15\x02\xe8\x03\x60\xfe\xb6\x00\x60\xfe\x64\x00\x65\x00\x66\x00\x24\x02\x20\x00\x21\x00\x22\x00\x2a\x02\x20\x00\x21\x00\x22\x00\x6a\x00\xae\x00\xcd\xfe\x1c\x00\xcd\xfe\xb3\x00\x1d\x00\x1e\x00\xdd\x00\x1f\x00\xfb\x03\x0c\x01\x0d\x01\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xb4\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xf1\x00\x65\x00\x66\x00\xc3\x03\x11\x02\x4d\x01\x6d\x00\x26\x00\xb6\x00\x09\x01\x64\x00\x65\x00\x66\x00\x68\x03\x11\x02\x9d\x03\x9e\x03\x9f\x03\xb6\x00\x5e\x01\x64\x00\x65\x00\x66\x00\x10\x02\x11\x02\x61\xfe\x4a\x01\x61\xfe\xb6\x00\x4b\x01\x64\x00\x65\x00\x66\x00\x28\x00\x29\x00\x7f\x03\x80\x02\x2c\x00\x2d\x00\x20\x00\x21\x00\x22\x00\xdf\x00\x24\x00\x25\x00\x3a\x04\x9f\x00\x61\x00\x36\x04\x62\x00\xa0\x00\x63\x00\x33\x04\x64\x00\x65\x00\x66\x00\x31\x04\x6a\x00\xe7\x00\x69\x00\xe8\x00\xe9\x00\x21\x00\xa1\x00\xfd\x02\x80\x02\xa2\x00\x88\x03\x7f\x02\x80\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x62\xfe\x63\x00\x62\xfe\x64\x00\x65\x00\x66\x00\x34\x04\x05\x04\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x32\x02\x84\x01\x33\x02\x61\x00\x63\xfe\x62\x00\x63\xfe\x63\x00\x29\x04\x64\x00\x65\x00\x66\x00\x23\x04\x6d\x00\xe7\x00\x69\x00\xe8\x00\xe9\x00\x06\x04\x21\x03\x22\x03\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xea\x00\x24\x03\x25\x03\x21\x00\x6b\x00\x16\x02\x6c\x00\x25\x00\x34\x02\x84\x01\x33\x02\x58\x00\x19\x04\x21\x00\x6b\x00\x1a\x04\x6c\x00\x25\x00\x20\x00\x21\x00\x22\x00\x6d\x00\x88\x02\x21\x00\x6b\x00\x1b\x02\x6c\x00\x25\x00\xb4\x02\x0d\x01\x5e\x00\x6d\x00\xb0\x00\x21\x00\x6b\x00\x1e\x04\x6c\x00\x25\x00\x20\x00\x21\x00\x22\x00\x6d\x00\x6a\xfe\x6a\x00\x6a\xfe\x20\x00\x21\x00\x22\x00\x32\x03\x33\x03\xea\x00\x6d\x00\xff\x03\x6b\xfe\x71\x03\x6b\xfe\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xca\x00\xcb\x00\xec\x00\xfb\x01\xcd\x00\xfc\x01\xce\x00\x20\x04\x9d\x00\x9e\x00\x6a\x00\xb7\x02\xb8\x02\x6d\x00\x01\x04\xc6\x00\xd2\x02\x7a\x01\xc7\x00\x5a\x02\xc8\x00\xf2\x01\xc9\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x86\x02\xca\x00\xcb\x00\xcc\x00\x6a\x00\xcd\x00\x4f\xff\xce\x00\x4c\x02\x0e\x04\x64\x00\x65\x00\x66\x00\x6d\x00\x88\x02\xeb\x00\x12\x04\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xca\x00\xcb\x00\xec\x00\x61\x00\xcd\x00\x62\x00\xce\x00\x63\x00\x13\x04\x64\x00\x65\x00\x66\x00\xd7\x03\x6d\x00\xe2\x00\x69\x00\x5a\x02\x84\x03\x7a\x02\x7b\x02\x7c\x02\xda\x03\x61\x00\xe6\x03\x62\x00\xf1\xfd\x63\x00\xf1\x03\x64\x00\x65\x00\x66\x00\x84\x01\xd5\x02\xe2\x00\x69\x00\xf2\x03\xe3\x00\x7e\x02\x7f\x02\x80\x02\xf3\x03\x61\x00\x85\x03\x62\x00\xf6\x03\x63\x00\xa1\x03\x64\x00\x65\x00\x66\x00\x5a\x02\x1c\x04\x68\x00\x69\x00\x6f\x02\xc3\x01\x4c\x00\x9d\x03\x4d\x00\x4e\x00\x61\x00\xfd\x03\x62\x00\xc5\x01\x63\x00\xa5\x03\x64\x00\x65\x00\x66\x00\xe1\x02\x02\x04\x68\x00\x69\x00\x90\x02\x7f\x02\x80\x02\x9f\x00\x84\x01\x85\x01\x61\x00\xa0\x00\x62\x00\xa6\x03\x63\x00\xa7\x03\x64\x00\x65\x00\x66\x00\xe2\x01\x0e\x04\x68\x00\x69\x00\x21\x00\xa1\x00\x2d\x02\x99\x00\xa2\x00\xe4\x00\x61\x00\xa9\x03\x62\x00\x2c\x00\x63\x00\xae\x03\x64\x00\x65\x00\x66\x00\xb9\x03\xe0\x03\x68\x00\x69\x00\xab\x00\xac\x00\x21\x00\x6b\x00\xb1\x03\x6c\x00\x25\x00\x61\x00\xba\x03\x62\x00\x6a\x00\x63\x00\xbd\x03\x64\x00\x65\x00\x66\x00\x21\x03\xe4\x03\x68\x00\x69\x00\x6d\x00\x79\x01\x7a\x01\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xc9\x03\x63\x00\xcc\x03\x64\x00\x65\x00\x66\x00\xce\x03\xc7\x03\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xcf\x03\x63\x00\x5a\x02\x64\x00\x65\x00\x66\x00\xd5\x03\x0d\x03\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xd3\x03\x63\x00\x3f\x03\x64\x00\x65\x00\x66\x00\x4c\x03\x26\x03\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x4d\x03\x63\x00\x4e\x03\x64\x00\x65\x00\x66\x00\x4f\x03\x4b\x02\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x52\x03\x63\x00\x5a\x02\x64\x00\x65\x00\x66\x00\x53\x03\x8e\x01\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x2c\x02\x2d\x02\x6a\x00\xf2\x01\xf3\x01\xd1\x01\x5a\x03\x64\x00\x65\x00\x66\x00\xf7\x01\xf8\x01\xf9\x01\x6d\x00\x6a\x03\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6b\x03\x62\x00\x6a\x00\x63\x00\xc8\x01\x64\x00\x65\x00\x66\x00\x7e\x02\xee\x01\x68\x00\x69\x00\x6d\x00\x2c\x02\x2d\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x6f\x03\x63\x00\xf2\xfd\x64\x00\x65\x00\x66\x00\x73\x03\xf3\x01\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x81\x03\x63\x00\x88\x02\x64\x00\x65\x00\x66\x00\x8a\x03\x4e\x01\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x8d\x03\x63\x00\x98\x03\x64\x00\x65\x00\x66\x00\xa5\x01\x67\x00\x68\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x2c\x00\x63\x00\xe2\x02\x64\x00\x65\x00\x66\x00\x42\x03\x43\x03\xe9\x03\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\xe1\x02\x62\x00\xe5\x02\x63\x00\x5a\x02\x64\x00\x65\x00\x66\x00\x2a\x00\x2b\x00\x8d\x02\x69\x00\x6d\x00\xee\x02\x21\x00\x6b\x00\xe9\x02\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xf0\x02\x63\x00\x28\xff\x64\x00\x65\x00\x66\x00\xe7\x02\xe8\x02\x8f\x02\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\xf1\x02\x62\x00\x6a\x00\x63\x00\xf2\x02\x64\x00\x65\x00\x66\x00\x39\x02\x3a\x02\x91\x02\x69\x00\x6d\x00\xff\x01\x00\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xf4\x02\x63\x00\x86\x02\x64\x00\x65\x00\x66\x00\xf2\x01\xf3\x01\xd2\x01\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xf5\x02\x63\x00\x88\x02\x64\x00\x65\x00\x66\x00\x2c\x02\x2d\x02\x03\x02\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xfc\x02\x63\x00\x88\x02\x64\x00\x65\x00\x66\x00\xff\x02\x0d\x03\x08\x02\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\xbd\x00\x63\x00\x12\x03\x64\x00\x65\x00\x66\x00\xbd\x00\x18\x03\x17\x02\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x1a\x03\x61\x00\x6a\x00\x12\x02\x1b\x03\xb6\x00\x1c\x03\x64\x00\x65\x00\x66\x00\xfc\x01\xf8\x01\xf9\x01\x6d\x00\x28\x03\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x21\x03\x63\x00\x29\x03\x64\x00\x65\x00\x66\x00\x2a\x03\x31\x03\xbd\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x32\x03\x62\x00\x6a\x00\x63\x00\x35\x03\x64\x00\x65\x00\x66\x00\x9b\x00\x3d\x03\xc1\x00\x69\x00\x6d\x00\x37\x02\x3b\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x3c\x02\x63\x00\xae\x00\x64\x00\x65\x00\x66\x00\x43\x02\x44\x02\xdb\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x61\x00\x6a\x00\x62\x00\x42\x02\x63\x00\x45\x02\x64\x00\x65\x00\x66\x00\x49\x02\xf2\x01\xf0\x00\x69\x00\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x4a\x02\x6a\x00\x61\x00\x99\x01\x9a\x01\x4b\x02\xb6\x00\x4f\x02\x64\x00\x65\x00\x66\x00\x52\x02\x53\x02\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x2d\xff\x5c\x02\x6a\x00\x61\x00\x5d\x02\xe0\x00\xf2\x01\xb6\x00\x64\x02\x64\x00\x65\x00\x66\x00\x6f\x02\x6d\x00\xfc\x01\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x6f\x02\x6a\x00\x7a\x02\x7e\x02\x29\x04\x70\x03\x65\x00\x66\x00\x2e\x02\x0c\x01\x0d\x01\x86\x02\x88\x02\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x8d\x02\x6a\x00\x00\x03\x01\x03\x93\x02\x64\x00\x65\x00\x66\x00\x0b\x01\x0c\x01\x0d\x01\x02\x03\x9b\x02\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x6b\x02\x6c\x02\x6d\x02\x6a\x00\x95\x02\xf1\x00\x65\x00\x66\x00\xf2\x00\x9c\x02\x03\x03\x04\x03\x05\x03\x6d\x00\x06\x03\xa2\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xa5\x02\x6a\x00\x00\x03\x79\x03\xb6\x02\x64\x00\x65\x00\x66\x00\x7c\x01\x7d\x01\x7e\x01\xb7\x02\x9d\x01\x6d\x00\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xcf\x02\xd0\x02\xd5\x02\x6a\x00\x75\x03\x70\x03\x65\x00\x66\x00\x2c\x00\x87\x01\x7a\x03\x04\x03\x05\x03\x6d\x00\x06\x03\xd7\x02\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\xc1\xfd\xa8\x01\x6a\x00\x1e\x04\x70\x03\x65\x00\x66\x00\xc3\xfd\xc2\xfd\xc5\xfd\xc8\xfd\x76\x03\x9c\x01\x6d\x00\x9d\x01\x21\x00\x6b\x00\x23\x00\x6c\x00\x25\x00\x9e\x01\xa9\x01\x03\x04\x70\x03\x65\x00\x66\x00\xb2\x01\x04\x04\x70\x03\x65\x00\x66\x00\x21\x00\x6b\x00\x6d\x00\x6c\x00\x25\x00\x28\x00\xb1\x01\xb3\x01\x07\x03\x3e\x02\xa8\x00\xa9\x00\xec\x03\x70\x03\x65\x00\x66\x00\xb4\x01\xe2\x00\x6d\x00\x21\x00\x6b\x00\xa6\x01\x08\x03\x25\x00\xae\x03\x70\x03\x65\x00\x66\x00\xbe\x01\xb5\x01\xbd\x01\xc7\x01\xf3\x00\xc6\x01\xc8\x01\xca\x01\xc9\x00\x6d\x00\x21\x00\x6b\x00\xc0\x01\x6c\x00\x25\x00\xca\x00\xcb\x00\xcf\x01\xd0\x01\xd1\x01\x07\x03\xb1\x03\x70\x03\x65\x00\x66\x00\xd8\x01\xd9\x01\xda\x01\x6d\x00\xf4\x00\xf5\x00\x21\x00\x6b\x00\xdc\x01\x08\x03\x25\x00\xdd\x01\x6f\x03\x70\x03\x65\x00\x66\x00\xe3\x01\x03\x02\xc8\x01\xc3\x01\x4c\x00\xc4\x01\x4d\x00\x4e\x00\x6d\x00\x21\x00\x6b\x00\xc5\x01\x6c\x00\x25\x00\x0b\x02\x15\x02\x19\x02\xb0\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x22\x02\x23\x02\x6d\x00\x2c\x00\x21\x00\x6b\x00\x32\x02\x6c\x00\x25\x00\x9d\x00\x29\x02\x58\x00\xff\xff\xb0\x00\xae\x00\xbf\x00\xbd\x00\xc0\x00\xc1\x00\xff\xff\xdf\x00\xf0\x00\x6d\x00\x21\x00\x6b\x00\xff\xff\x6c\x00\x25\x00\x21\x00\x6b\x00\x5e\x00\x6c\x00\x25\x00\xfc\x00\xfd\x00\x9f\x00\xfe\x00\xff\xff\x01\x01\xa0\x00\xbd\x00\x6d\x00\x01\x01\x72\x01\x21\x00\x6b\x00\x6d\x00\x6c\x00\x25\x00\x28\x00\x71\x01\x21\x00\xa1\x00\xff\xff\xff\xff\xa2\x00\x21\x00\x6b\x00\x00\x00\x6c\x00\x25\x00\x17\xfe\x6d\x00\x68\x02\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x02\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x6b\x00\x00\x00\x6c\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x21\x00\x6b\x00\x6d\x00\x6c\x00\x25\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x6d\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x3d\x00\x00\x00\x53\x00\x54\x00\x55\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x58\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x3c\x03\x00\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x5b\x00\x00\x00\x88\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x8e\x00\x5f\x00\x60\x00\x61\x00\x8f\x00\x90\x00\x00\x00\x00\x00\x00\x00\x91\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\xc6\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x73\x01\x3a\x00\xc9\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\xca\x00\xcb\x00\xcc\x00\x3d\x00\xcd\x00\x00\x00\xce\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x3c\x03\x00\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x5b\x00\x00\x00\x88\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x8e\x00\x5f\x00\x60\x00\x61\x00\x8f\x00\x90\x00\x00\x00\x00\x00\x00\x00\x91\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x5b\x00\x28\x00\x88\x00\x00\x00\x5c\x00\x2c\x00\x2d\x00\x89\x00\x00\x00\x46\xff\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x8e\x00\x5f\x00\x60\x00\x61\x00\x8f\x00\x90\x00\x6f\x00\x00\x00\x70\x00\x91\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x28\x00\x71\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x46\xff\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x7c\x03\xfb\x00\x00\x00\x7d\x03\x6f\x00\x00\x00\x70\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x28\x00\x4d\x01\x00\x00\x71\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x46\xff\xd9\x00\xda\x00\xdb\x00\x00\x00\x4a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x08\x04\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\xff\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\x7d\x03\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x5e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x72\x00\x28\x00\x58\x00\x7e\x03\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x4b\x03\x5e\x00\x6f\x00\x28\x00\x70\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x5e\x00\x58\x00\x00\x00\x71\x00\x09\x04\x00\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x00\x00\x28\x00\x6f\x00\x00\x00\x70\x00\x2c\x00\x2d\x00\x5e\x00\x00\x00\x0b\x03\xee\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x03\x00\x00\xe7\x00\x0a\x03\x00\x00\x70\x00\xd6\x00\xc5\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x78\x03\x71\x00\xef\x00\x00\x00\x00\x00\x00\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x0b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x0c\x03\xc6\x00\x00\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\xc9\x00\x00\x00\x5e\x00\x58\x00\x00\x00\x00\x00\x00\x00\xca\x00\xcb\x00\xcc\x00\x00\x00\xcd\x00\x00\x00\xce\x00\x79\x03\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\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x0c\x03\x41\x01\xd1\x00\xd2\x00\xd3\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xce\x02\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xa4\x01\x3b\x00\x3c\x00\x42\x01\x43\x01\x00\x00\xd7\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x44\x01\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\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\x5f\x00\x60\x00\x61\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x41\x01\xd1\x00\xd2\x00\xd3\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xa3\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xa4\x01\x3b\x00\x3c\x00\x42\x01\x43\x01\x00\x00\xd7\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x44\x01\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\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\x5f\x00\x60\x00\x61\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x68\x01\xd1\x00\xd2\x00\xd3\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x69\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xe7\x00\x3b\x00\x3c\x00\x42\x01\x6a\x01\x00\x00\xd7\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x6b\x01\x6c\x01\x6d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\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\x5f\x00\x60\x00\x61\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x41\x01\xd1\x00\xd2\x00\xd3\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x5e\x01\x00\x00\x3b\x00\x3c\x00\x42\x01\x43\x01\x00\x00\xd7\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x44\x01\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\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\x5f\x00\x60\x00\x61\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x41\x01\xd1\x00\xd2\x00\xd3\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x42\x01\x43\x01\x00\x00\xd7\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x44\x01\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x28\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x69\x02\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\xcd\x01\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x4f\x00\x3b\x00\x3c\x00\x00\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x5e\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\xc5\x03\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x02\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\xc3\x02\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x02\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xe0\x02\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x02\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\xa4\x00\x38\x04\x58\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x39\x04\x00\x00\x00\x00\x00\x00\x5e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x58\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x5e\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\xc2\x03\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x58\x00\x00\x00\x00\x00\x00\x00\x83\x00\x84\x00\x85\x00\xb8\x03\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\xc2\x03\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x58\x00\x00\x00\x00\x00\x00\x00\x83\x00\x84\x00\x85\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x62\x03\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xe6\x01\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x7f\x03\x63\x03\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x28\x00\x29\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x95\x01\x58\x00\x00\x00\x00\x00\x00\x00\x83\x00\x84\x00\x85\x00\x00\x00\x96\x01\x5b\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x58\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x5e\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x62\x03\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xe6\x01\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x63\x03\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x58\x00\x00\x00\x00\x00\x00\x00\x83\x00\x84\x00\x85\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x01\x00\x00\x00\x00\x5e\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\xaa\x02\x29\x00\x2a\x00\x2b\x00\xab\x02\x2d\x00\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x23\xff\x00\x00\x00\x00\x00\x00\x12\x01\xac\x02\xad\x02\xae\x02\xaf\x02\xb0\x02\xb1\x02\xb2\x02\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\xb3\x02\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\xb4\x02\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x23\xff\x23\xff\x23\xff\x23\xff\x23\xff\x23\xff\x23\xff\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x23\xff\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x23\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x5b\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x75\x01\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\xd9\x00\xda\x00\xdb\x00\x76\x01\x77\x01\x78\x01\x79\x01\x28\x00\xae\x01\x00\x00\x3e\x00\x2c\x00\x00\x00\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\xa4\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x4a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x04\x01\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x5e\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x11\x01\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\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\x58\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\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\x5e\x00\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\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\xee\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x71\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x5e\x00\x2c\x00\x2d\x00\x00\x00\xf7\x00\xd1\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\x6f\x00\x00\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\xd7\x00\x72\x00\x00\x00\x58\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xfa\x00\xfb\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\x5e\x00\x2c\x00\x2d\x00\x00\x00\xf7\x00\xd1\x00\x00\x00\xd3\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\xd4\x00\x00\x00\xd7\x00\xd5\x00\xd6\x00\x58\x00\xd7\x00\xd8\x00\xf9\x00\x28\x00\x14\x02\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\xe6\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x71\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x87\x03\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\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\x28\x00\x5e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x00\x00\x72\x00\x00\x00\x58\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\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\x6f\x00\x00\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x28\x00\x58\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x28\x00\xdd\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x28\x00\x6f\x00\x00\x00\x70\x00\x71\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x28\x00\x70\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x71\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x28\x00\x00\x00\x00\x00\x58\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x72\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x6f\x00\x5e\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x58\x00\x71\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x28\x00\x5e\x00\x00\x00\x58\x00\x2c\x00\x2d\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x5e\x00\x70\x00\x71\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x94\x02\x28\x00\x00\x00\x5e\x00\x00\x00\x2c\x00\x2d\x00\x94\x02\xb8\x00\x00\x00\x00\x00\x58\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x71\x00\x4d\x01\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x28\x00\x58\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x58\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x4d\x01\x71\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x58\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x4b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x5e\x00\x49\x01\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4a\x01\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x28\x00\x58\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x58\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\xa4\x00\xdf\x03\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\xa4\x00\x5e\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x03\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xa4\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\x28\x00\x29\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x58\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\xa5\x00\x00\x00\x5e\x00\x00\x00\x28\x00\xa4\x00\xa6\x00\x00\x00\x2c\x00\x5e\x00\x58\x00\x28\x00\x29\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\xa4\x00\xa6\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x28\x00\xb2\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x2f\x03\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x28\x00\x10\x03\x00\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x2f\x03\x00\x00\x5e\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x58\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x58\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x02\xbe\x02\xbf\x02\xc0\x02\x00\x00\xc1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xd4\x00\x00\x00\x00\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\xd8\x00\xcc\xfe\x00\x00\xcc\xfe\x93\x03\xbf\x02\xc0\x02\x00\x00\xc1\x02\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x03\xc0\x02\x00\x00\xc1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x03\x71\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xee\x02\x00\x00\xcb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x02\x71\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x98\x02\x00\x00\xcb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x02\x71\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xca\x01\x00\x00\xcb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xcd\x01\x00\x00\xcb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x20\x04\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\xfd\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xf7\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x99\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x9a\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x9b\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xc9\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x57\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x6b\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x6c\x03\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xde\x02\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x74\x02\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x96\x01\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x51\x01\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x52\x01\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x93\x00\x94\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x60\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x61\x01\x62\x01\x00\x00\x00\x00\x63\x01\x19\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\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\x64\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x65\x01\x3d\x01\xcd\x00\x3e\x01\x66\x01\x26\x00\x38\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\x5c\x01\x00\x00\xc4\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xc5\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x38\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xc6\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xcc\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x38\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xa1\x01\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x39\x01\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x3b\x01\x00\x00\x00\x00\x3c\x01\xc9\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xca\x00\xcb\x00\x00\x00\x3d\x01\x00\x00\x3e\x01\x3f\x01\x26\x00\x91\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x91\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x8d\x03\x8e\x03\x00\x00\x19\x00\x00\x00\x8f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\xf6\x03\x00\x00\x00\x00\x00\x00\x8f\x03\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\xa2\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\xa3\x02\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xc8\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x02\x19\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\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x53\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x54\x01\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x91\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x21\x04\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x8a\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x98\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xda\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x95\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x96\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x9c\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x9e\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xbb\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\xbc\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xc3\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\xc7\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x8a\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x8b\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x8c\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x8d\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x06\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x08\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x2f\x03\x10\x00\x50\x01\x12\x00\x13\x00\x14\x00\x15\x00\x26\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x10\x00\x50\x01\x12\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x4f\x01\x10\x00\x50\x01\x12\x00\x13\x00\x14\x00\x15\x00\x26\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x01\x90\x01\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x90\x01\x00\x00\x15\x00\x00\x00\x26\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x01\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x58\x01\x59\x01\x02\x01\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x02\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x01\x01\x02\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xa6\x02\x0c\x01\x0d\x01\x00\x00\xa7\x02\x36\x03\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xa5\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x19\x00\x00\x00\x00\x00\xa6\x02\x0c\x01\x0d\x01\x00\x00\xa7\x02\xa8\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x03\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x3c\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x97\x01\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x98\x01\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x72\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\xc8\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x25\x02\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x29\x02\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\xc4\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x55\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x57\x01\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x72\x01\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++happyReduceArr = Happy_Data_Array.array (8, 600) [+ (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),+ (531 , happyReduce_531),+ (532 , happyReduce_532),+ (533 , happyReduce_533),+ (534 , happyReduce_534),+ (535 , happyReduce_535),+ (536 , happyReduce_536),+ (537 , happyReduce_537),+ (538 , happyReduce_538),+ (539 , happyReduce_539),+ (540 , happyReduce_540),+ (541 , happyReduce_541),+ (542 , happyReduce_542),+ (543 , happyReduce_543),+ (544 , happyReduce_544),+ (545 , happyReduce_545),+ (546 , happyReduce_546),+ (547 , happyReduce_547),+ (548 , happyReduce_548),+ (549 , happyReduce_549),+ (550 , happyReduce_550),+ (551 , happyReduce_551),+ (552 , happyReduce_552),+ (553 , happyReduce_553),+ (554 , happyReduce_554),+ (555 , happyReduce_555),+ (556 , happyReduce_556),+ (557 , happyReduce_557),+ (558 , happyReduce_558),+ (559 , happyReduce_559),+ (560 , happyReduce_560),+ (561 , happyReduce_561),+ (562 , happyReduce_562),+ (563 , happyReduce_563),+ (564 , happyReduce_564),+ (565 , happyReduce_565),+ (566 , happyReduce_566),+ (567 , happyReduce_567),+ (568 , happyReduce_568),+ (569 , happyReduce_569),+ (570 , happyReduce_570),+ (571 , happyReduce_571),+ (572 , happyReduce_572),+ (573 , happyReduce_573),+ (574 , happyReduce_574),+ (575 , happyReduce_575),+ (576 , happyReduce_576),+ (577 , happyReduce_577),+ (578 , happyReduce_578),+ (579 , happyReduce_579),+ (580 , happyReduce_580),+ (581 , happyReduce_581),+ (582 , happyReduce_582),+ (583 , happyReduce_583),+ (584 , happyReduce_584),+ (585 , happyReduce_585),+ (586 , happyReduce_586),+ (587 , happyReduce_587),+ (588 , happyReduce_588),+ (589 , happyReduce_589),+ (590 , happyReduce_590),+ (591 , happyReduce_591),+ (592 , happyReduce_592),+ (593 , happyReduce_593),+ (594 , happyReduce_594),+ (595 , happyReduce_595),+ (596 , happyReduce_596),+ (597 , happyReduce_597),+ (598 , happyReduce_598),+ (599 , happyReduce_599),+ (600 , happyReduce_600)+ ]++happy_n_terms = 138 :: Int+happy_n_nonterms = 219 :: Int++happyReduce_8 = happySpecReduce_2 0# happyReduction_8+happyReduction_8 happy_x_2+ happy_x_1+ = case happyOut15 happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11+ (let (os,ss,l) = happy_var_1 in map (\x -> x os ss l) happy_var_2+ )}}++happyReduce_9 = happySpecReduce_2 1# happyReduction_9+happyReduction_9 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn12+ (happy_var_1 : happy_var_2+ )}}++happyReduce_10 = happySpecReduce_1 1# happyReduction_10+happyReduction_10 happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn12+ ([happy_var_1]+ )}++happyReduce_11 = happyMonadReduce 2# 2# happyReduction_11+happyReduction_11 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut15 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + ( checkPageModule happy_var_2 happy_var_1)}}+ ) (\r -> happyReturn (happyIn13 r))++happyReduce_12 = happyMonadReduce 5# 2# happyReduction_12+happyReduction_12 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut15 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 XCodeTagOpen) -> + case happyOut19 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 XCodeTagClose) -> + case happyOut14 happy_x_5 of { happy_var_5 -> + ( let (os,ss,l) = happy_var_1 in checkHybridModule happy_var_5 (happy_var_3 os ss l) happy_var_2 happy_var_4)}}}}}+ ) (\r -> happyReturn (happyIn13 r))++happyReduce_13 = happySpecReduce_2 2# happyReduction_13+happyReduction_13 happy_x_2+ happy_x_1+ = case happyOut15 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_2 of { happy_var_2 -> + happyIn13+ (let (os,ss,l) = happy_var_1 in happy_var_2 os ss l+ )}}++happyReduce_14 = happyMonadReduce 9# 3# happyReduction_14+happyReduction_14 (happy_x_9 `HappyStk`+ happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> + case happyOut161 happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOut166 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> + case happyOut159 happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { (Loc happy_var_7 XCloseTagOpen) -> + case happyOut161 happy_x_8 of { happy_var_8 -> + case happyOutTok happy_x_9 of { (Loc happy_var_9 XStdTagClose) -> + ( do { n <- checkEqNames happy_var_2 happy_var_8;+ let { cn = reverse happy_var_6;+ as = reverse happy_var_3; };+ return $ XTag (happy_var_1 <^^> happy_var_9 <** [happy_var_1,happy_var_5,happy_var_7,happy_var_9]) n as happy_var_4 cn })}}}}}}}}}+ ) (\r -> happyReturn (happyIn14 r))++happyReduce_15 = happyReduce 5# 3# happyReduction_15+happyReduction_15 (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 { (Loc happy_var_1 XStdTagOpen) -> + case happyOut161 happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOut166 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> + happyIn14+ (XETag (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_16 = happySpecReduce_3 4# happyReduction_16+happyReduction_16 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn15+ (let (os,ss,ml) = happy_var_2 in (os,happy_var_1:ss++[happy_var_3],happy_var_1 <^^> happy_var_3)+ )}}}++happyReduce_17 = happySpecReduce_3 5# happyReduction_17+happyReduction_17 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn16+ (let (os,ss,ml) = happy_var_3 in (happy_var_1 : os, happy_var_2 : ss, Just $ ann happy_var_1 <++> nIS happy_var_2 <+?> ml)+ )}}}++happyReduce_18 = happySpecReduce_0 5# happyReduction_18+happyReduction_18 = happyIn16+ (([],[],Nothing)+ )++happyReduce_19 = happyReduce 4# 6# happyReduction_19+happyReduction_19 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LANGUAGE) -> + case happyOut18 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> + happyIn17+ (LanguagePragma (happy_var_1 <^^> happy_var_4 <** (happy_var_1:snd happy_var_2 ++ reverse happy_var_3 ++ [happy_var_4])) (fst happy_var_2)+ ) `HappyStk` happyRest}}}}++happyReduce_20 = happySpecReduce_3 6# happyReduction_20+happyReduction_20 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn17+ (let Loc l (OPTIONS (mc, s)) = happy_var_1+ in OptionsPragma (l <^^> happy_var_3 <** (l:reverse happy_var_2 ++ [happy_var_3])) (readTool mc) s+ )}}}++happyReduce_21 = happySpecReduce_3 6# happyReduction_21+happyReduction_21 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn17+ (AnnModulePragma (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_22 = happySpecReduce_3 7# happyReduction_22+happyReduction_22 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut213 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn18+ ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+ )}}}++happyReduce_23 = happySpecReduce_1 7# happyReduction_23+happyReduction_23 happy_x_1+ = case happyOut213 happy_x_1 of { happy_var_1 -> + happyIn18+ (([happy_var_1],[])+ )}++happyReduce_24 = happySpecReduce_2 8# happyReduction_24+happyReduction_24 happy_x_2+ happy_x_1+ = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn19+ (let (is,ds,ss1,inf) = happy_var_2+ in \os ss l -> Module (l <++> inf <** (ss ++ ss1)) happy_var_1 os is ds+ )}}++happyReduce_25 = happyReduce 5# 9# happyReduction_25+happyReduction_25 (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 { (Loc happy_var_1 KW_Module) -> + case happyOut224 happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOut26 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Where) -> + happyIn20+ (Just $ ModuleHead (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 happy_var_3 happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_26 = happySpecReduce_0 9# happyReduction_26+happyReduction_26 = happyIn20+ (Nothing+ )++happyReduce_27 = happySpecReduce_3 10# happyReduction_27+happyReduction_27 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn21+ (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ DeprText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s+ )}}}++happyReduce_28 = happySpecReduce_3 10# happyReduction_28+happyReduction_28 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn21+ (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ WarnText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s+ )}}}++happyReduce_29 = happySpecReduce_0 10# happyReduction_29+happyReduction_29 = happyIn21+ (Nothing+ )++happyReduce_30 = happySpecReduce_3 11# happyReduction_30+happyReduction_30 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> + case happyOut23 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + happyIn22+ (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)+ )}}}++happyReduce_31 = happySpecReduce_3 11# happyReduction_31+happyReduction_31 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn22+ (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)+ )}}}++happyReduce_32 = happyReduce 4# 12# happyReduction_32+happyReduction_32 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_2 of { happy_var_2 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + case happyOut48 happy_x_4 of { happy_var_4 -> + happyIn23+ ((reverse (fst happy_var_2), fst happy_var_4, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3 ++ snd happy_var_4)+ ) `HappyStk` happyRest}}}}++happyReduce_33 = happySpecReduce_2 12# happyReduction_33+happyReduction_33 happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn23+ (([], fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2)+ )}}++happyReduce_34 = happySpecReduce_3 12# happyReduction_34+happyReduction_34 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn23+ ((reverse (fst happy_var_2), [], reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+ )}}}++happyReduce_35 = happySpecReduce_1 12# happyReduction_35+happyReduction_35 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn23+ (([], [], reverse happy_var_1)+ )}++happyReduce_36 = happySpecReduce_2 13# happyReduction_36+happyReduction_36 happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> + happyIn24+ (happy_var_2 : happy_var_1+ )}}++happyReduce_37 = happySpecReduce_1 14# happyReduction_37+happyReduction_37 happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn25+ (happy_var_1+ )}++happyReduce_38 = happySpecReduce_0 14# happyReduction_38+happyReduction_38 = happyIn25+ ([]+ )++happyReduce_39 = happySpecReduce_1 15# happyReduction_39+happyReduction_39 happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn26+ (Just happy_var_1+ )}++happyReduce_40 = happySpecReduce_0 15# happyReduction_40+happyReduction_40 = happyIn26+ (Nothing+ )++happyReduce_41 = happyReduce 4# 16# happyReduction_41+happyReduction_41 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut29 happy_x_2 of { happy_var_2 -> + case happyOut28 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn27+ (ExportSpecList (happy_var_1 <^^> happy_var_4 <** (happy_var_1:reverse (snd happy_var_2) ++ happy_var_3 ++ [happy_var_4])) (reverse (fst happy_var_2))+ ) `HappyStk` happyRest}}}}++happyReduce_42 = happySpecReduce_3 16# happyReduction_42+happyReduction_42 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut28 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn27+ (ExportSpecList (happy_var_1 <^^> happy_var_3 <** (happy_var_1:happy_var_2++[happy_var_3])) []+ )}}}++happyReduce_43 = happySpecReduce_1 17# happyReduction_43+happyReduction_43 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> + happyIn28+ ([happy_var_1]+ )}++happyReduce_44 = happySpecReduce_0 17# happyReduction_44+happyReduction_44 = happyIn28+ ([ ]+ )++happyReduce_45 = happySpecReduce_3 18# happyReduction_45+happyReduction_45 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut29 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut30 happy_x_3 of { happy_var_3 -> + happyIn29+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_46 = happySpecReduce_1 18# happyReduction_46+happyReduction_46 happy_x_1+ = case happyOut30 happy_x_1 of { happy_var_1 -> + happyIn29+ (([happy_var_1],[])+ )}++happyReduce_47 = happySpecReduce_1 19# happyReduction_47+happyReduction_47 happy_x_1+ = case happyOut195 happy_x_1 of { happy_var_1 -> + happyIn30+ (EVar (ann happy_var_1) happy_var_1+ )}++happyReduce_48 = happySpecReduce_1 19# happyReduction_48+happyReduction_48 happy_x_1+ = case happyOut226 happy_x_1 of { happy_var_1 -> + happyIn30+ (EAbs (ann happy_var_1) happy_var_1+ )}++happyReduce_49 = happyReduce 4# 19# happyReduction_49+happyReduction_49 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut226 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn30+ (EThingAll (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1+ ) `HappyStk` happyRest}}}}++happyReduce_50 = happySpecReduce_3 19# happyReduction_50+happyReduction_50 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut226 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn30+ (EThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]) happy_var_1 []+ )}}}++happyReduce_51 = happyReduce 4# 19# happyReduction_51+happyReduction_51 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut226 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut42 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn30+ (EThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))+ ) `HappyStk` happyRest}}}}++happyReduce_52 = happySpecReduce_2 19# happyReduction_52+happyReduction_52 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> + case happyOut224 happy_x_2 of { happy_var_2 -> + happyIn30+ (EModuleContents (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_53 = happySpecReduce_3 20# happyReduction_53+happyReduction_53 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut31 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut32 happy_x_3 of { happy_var_3 -> + happyIn31+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_54 = happySpecReduce_1 20# happyReduction_54+happyReduction_54 happy_x_1+ = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn31+ (([happy_var_1],[])+ )}++happyReduce_55 = happyReduce 7# 21# happyReduction_55+happyReduction_55 (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 { (Loc happy_var_1 KW_Import) -> + case happyOut33 happy_x_2 of { happy_var_2 -> + case happyOut34 happy_x_3 of { happy_var_3 -> + case happyOut35 happy_x_4 of { happy_var_4 -> + case happyOut224 happy_x_5 of { happy_var_5 -> + case happyOut36 happy_x_6 of { happy_var_6 -> + case happyOut37 happy_x_7 of { happy_var_7 -> + happyIn32+ (let { (mmn,ss,ml) = happy_var_6 ;+ l = nIS happy_var_1 <++> ann happy_var_5 <+?> ml <+?> (fmap ann) happy_var_7 <** (happy_var_1:snd happy_var_2 ++ snd happy_var_3 ++ snd happy_var_4 ++ ss)}+ in ImportDecl l happy_var_5 (fst happy_var_3) (fst happy_var_2) (fst happy_var_4) mmn happy_var_7+ ) `HappyStk` happyRest}}}}}}}++happyReduce_56 = happySpecReduce_2 22# happyReduction_56+happyReduction_56 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 SOURCE) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> + happyIn33+ ((True,[happy_var_1,happy_var_2])+ )}}++happyReduce_57 = happySpecReduce_0 22# happyReduction_57+happyReduction_57 = happyIn33+ ((False,[])+ )++happyReduce_58 = happySpecReduce_1 23# happyReduction_58+happyReduction_58 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> + happyIn34+ ((True,[happy_var_1])+ )}++happyReduce_59 = happySpecReduce_0 23# happyReduction_59+happyReduction_59 = happyIn34+ ((False, [])+ )++happyReduce_60 = happyMonadReduce 1# 24# happyReduction_60+happyReduction_60 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( do { checkEnabled PackageImports ;+ let { Loc l (StringTok (s,_)) = happy_var_1 } ;+ return $ (Just s,[l]) })}+ ) (\r -> happyReturn (happyIn35 r))++happyReduce_61 = happySpecReduce_0 24# happyReduction_61+happyReduction_61 = happyIn35+ ((Nothing,[])+ )++happyReduce_62 = happySpecReduce_2 25# happyReduction_62+happyReduction_62 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> + case happyOut224 happy_x_2 of { happy_var_2 -> + happyIn36+ ((Just happy_var_2,[happy_var_1],Just (nIS happy_var_1 <++> ann happy_var_2))+ )}}++happyReduce_63 = happySpecReduce_0 25# happyReduction_63+happyReduction_63 = happyIn36+ ((Nothing,[],Nothing)+ )++happyReduce_64 = happySpecReduce_1 26# happyReduction_64+happyReduction_64 happy_x_1+ = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn37+ (Just happy_var_1+ )}++happyReduce_65 = happySpecReduce_0 26# happyReduction_65+happyReduction_65 = happyIn37+ (Nothing+ )++happyReduce_66 = happyReduce 5# 27# happyReduction_66+happyReduction_66 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut39 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut40 happy_x_3 of { happy_var_3 -> + case happyOut28 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> + happyIn38+ (let {(b,ml,s) = happy_var_1 ;+ l = (ml <?+> (happy_var_2 <^^> happy_var_5)) <** (s ++ happy_var_2:reverse (snd happy_var_3) ++ happy_var_4 ++ [happy_var_5])}+ in ImportSpecList l b (reverse (fst happy_var_3))+ ) `HappyStk` happyRest}}}}}++happyReduce_67 = happyReduce 4# 27# happyReduction_67+happyReduction_67 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut39 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut28 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn38+ (let {(b,ml,s) = happy_var_1 ; l = (ml <?+> (happy_var_2 <^^> happy_var_4)) <** (s ++ happy_var_2:happy_var_3 ++ [happy_var_4])}+ in ImportSpecList l b []+ ) `HappyStk` happyRest}}}}++happyReduce_68 = happySpecReduce_1 28# happyReduction_68+happyReduction_68 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> + happyIn39+ ((True,Just (nIS happy_var_1),[happy_var_1])+ )}++happyReduce_69 = happySpecReduce_0 28# happyReduction_69+happyReduction_69 = happyIn39+ ((False,Nothing,[])+ )++happyReduce_70 = happySpecReduce_3 29# happyReduction_70+happyReduction_70 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut41 happy_x_3 of { happy_var_3 -> + happyIn40+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_71 = happySpecReduce_1 29# happyReduction_71+happyReduction_71 happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn40+ (([happy_var_1],[])+ )}++happyReduce_72 = happySpecReduce_1 30# happyReduction_72+happyReduction_72 happy_x_1+ = case happyOut193 happy_x_1 of { happy_var_1 -> + happyIn41+ (IVar (ann happy_var_1) happy_var_1+ )}++happyReduce_73 = happySpecReduce_1 30# happyReduction_73+happyReduction_73 happy_x_1+ = case happyOut225 happy_x_1 of { happy_var_1 -> + happyIn41+ (IAbs (ann happy_var_1) happy_var_1+ )}++happyReduce_74 = happyReduce 4# 30# happyReduction_74+happyReduction_74 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn41+ (IThingAll (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1+ ) `HappyStk` happyRest}}}}++happyReduce_75 = happySpecReduce_3 30# happyReduction_75+happyReduction_75 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn41+ (IThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]) happy_var_1 []+ )}}}++happyReduce_76 = happyReduce 4# 30# happyReduction_76+happyReduction_76 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut42 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn41+ (IThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))+ ) `HappyStk` happyRest}}}}++happyReduce_77 = happySpecReduce_3 31# happyReduction_77+happyReduction_77 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut42 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut43 happy_x_3 of { happy_var_3 -> + happyIn42+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_78 = happySpecReduce_1 31# happyReduction_78+happyReduction_78 happy_x_1+ = case happyOut43 happy_x_1 of { happy_var_1 -> + happyIn42+ (([happy_var_1],[])+ )}++happyReduce_79 = happySpecReduce_1 32# happyReduction_79+happyReduction_79 happy_x_1+ = case happyOut193 happy_x_1 of { happy_var_1 -> + happyIn43+ (VarName (ann happy_var_1) happy_var_1+ )}++happyReduce_80 = happySpecReduce_1 32# happyReduction_80+happyReduction_80 happy_x_1+ = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn43+ (ConName (ann happy_var_1) happy_var_1+ )}++happyReduce_81 = happySpecReduce_3 33# happyReduction_81+happyReduction_81 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut46 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_2 of { happy_var_2 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + happyIn44+ (let (ops,ss,l) = happy_var_3+ in InfixDecl (ann happy_var_1 <++> l <** (snd happy_var_2 ++ reverse ss)) happy_var_1 (fst happy_var_2) (reverse ops)+ )}}}++happyReduce_82 = happySpecReduce_0 34# happyReduction_82+happyReduction_82 = happyIn45+ ((Nothing, [])+ )++happyReduce_83 = happyMonadReduce 1# 34# happyReduction_83+happyReduction_83 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( let Loc l (IntTok (i,_)) = happy_var_1 in checkPrec i >>= \i -> return (Just i, [l]))}+ ) (\r -> happyReturn (happyIn45 r))++happyReduce_84 = happySpecReduce_1 35# happyReduction_84+happyReduction_84 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> + happyIn46+ (AssocNone $ nIS happy_var_1+ )}++happyReduce_85 = happySpecReduce_1 35# happyReduction_85+happyReduction_85 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> + happyIn46+ (AssocLeft $ nIS happy_var_1+ )}++happyReduce_86 = happySpecReduce_1 35# happyReduction_86+happyReduction_86 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> + happyIn46+ (AssocRight $ nIS happy_var_1+ )}++happyReduce_87 = happySpecReduce_3 36# happyReduction_87+happyReduction_87 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut204 happy_x_3 of { happy_var_3 -> + happyIn47+ (let (ops,ss,l) = happy_var_1 in (happy_var_3 : ops, happy_var_2 : ss, l <++> ann happy_var_3)+ )}}}++happyReduce_88 = happySpecReduce_1 36# happyReduction_88+happyReduction_88 happy_x_1+ = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn47+ (([happy_var_1],[],ann happy_var_1)+ )}++happyReduce_89 = happyMonadReduce 2# 37# happyReduction_89+happyReduction_89 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut49 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_2 of { happy_var_2 -> + ( checkRevDecls (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1 ++ reverse happy_var_2))}}+ ) (\r -> happyReturn (happyIn48 r))++happyReduce_90 = happySpecReduce_3 38# happyReduction_90+happyReduction_90 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut49 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut50 happy_x_3 of { happy_var_3 -> + happyIn49+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_91 = happySpecReduce_1 38# happyReduction_91+happyReduction_91 happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn49+ (([happy_var_1],[])+ )}++happyReduce_92 = happyMonadReduce 4# 39# happyReduction_92+happyReduction_92 (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 { (Loc happy_var_1 KW_Type) -> + case happyOut78 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> + case happyOut88 happy_x_4 of { happy_var_4 -> + ( do { dh <- checkSimpleType happy_var_2;+ let {l = nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]};+ return (TypeDecl l dh happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_93 = happyMonadReduce 4# 39# happyReduction_93+happyReduction_93 (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 { (Loc happy_var_1 KW_Type) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> + case happyOut80 happy_x_3 of { happy_var_3 -> + case happyOut122 happy_x_4 of { happy_var_4 -> + ( do { dh <- checkSimpleType happy_var_3;+ let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};+ return (TypeFamDecl l dh (fst happy_var_4)) })}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_94 = happyMonadReduce 5# 39# happyReduction_94+happyReduction_94 (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 { (Loc happy_var_1 KW_Type) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> + case happyOut77 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 Equals) -> + case happyOut88 happy_x_5 of { happy_var_5 -> + ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns+ checkEnabled TypeFamilies ;+ let {l = nIS happy_var_1 <++> ann happy_var_5 <** [happy_var_1,happy_var_2,happy_var_4]};+ return (TypeInsDecl l happy_var_3 happy_var_5) })}}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_95 = happyMonadReduce 4# 39# happyReduction_95+happyReduction_95 (happy_x_4 `HappyStk`+ 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 happyOut89 happy_x_2 of { happy_var_2 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + case happyOut116 happy_x_4 of { happy_var_4 -> + ( do { (cs,dh) <- checkDataHeader happy_var_2;+ let { (qds,ss,minf) = happy_var_3;+ l = happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss};+ checkDataOrNew happy_var_1 qds;+ return (DataDecl l happy_var_1 cs dh (reverse qds) happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_96 = happyMonadReduce 5# 39# happyReduction_96+happyReduction_96 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ 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 happyOut89 happy_x_2 of { happy_var_2 -> + case happyOut122 happy_x_3 of { happy_var_3 -> + case happyOut100 happy_x_4 of { happy_var_4 -> + case happyOut116 happy_x_5 of { happy_var_5 -> + ( do { (cs,dh) <- checkDataHeader happy_var_2;+ let { (gs,ss,minf) = happy_var_4;+ l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)};+ checkDataOrNewG happy_var_1 gs;+ case (gs, fst happy_var_3) of+ ([], Nothing) -> return (DataDecl l happy_var_1 cs dh [] happy_var_5)+ _ -> checkEnabled GADTs >> return (GDataDecl l happy_var_1 cs dh (fst happy_var_3) (reverse gs) happy_var_5) })}}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_97 = happyMonadReduce 4# 39# happyReduction_97+happyReduction_97 (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 { (Loc happy_var_1 KW_Data) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + case happyOut122 happy_x_4 of { happy_var_4 -> + ( do { (cs,dh) <- checkDataHeader happy_var_3;+ let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};+ return (DataFamDecl l cs dh (fst happy_var_4)) })}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_98 = happyMonadReduce 5# 39# happyReduction_98+happyReduction_98 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ 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 happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> + case happyOut88 happy_x_3 of { happy_var_3 -> + case happyOut104 happy_x_4 of { happy_var_4 -> + case happyOut116 happy_x_5 of { happy_var_5 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+ checkEnabled TypeFamilies ;+ let { (qds,ss,minf) = happy_var_4 ;+ l = happy_var_1 <> happy_var_3 <+?> minf <+?> fmap ann happy_var_5 <** happy_var_2:ss };+ checkDataOrNew happy_var_1 qds;+ return (DataInsDecl l happy_var_1 happy_var_3 (reverse qds) happy_var_5) })}}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_99 = happyMonadReduce 6# 39# happyReduction_99+happyReduction_99 (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 happyOut51 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> + case happyOut88 happy_x_3 of { happy_var_3 -> + case happyOut122 happy_x_4 of { happy_var_4 -> + case happyOut100 happy_x_5 of { happy_var_5 -> + case happyOut116 happy_x_6 of { happy_var_6 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+ checkEnabled TypeFamilies ;+ let {(gs,ss,minf) = happy_var_5;+ l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_6 <** (happy_var_2:snd happy_var_4 ++ ss)};+ checkDataOrNewG happy_var_1 gs;+ return (GDataInsDecl l happy_var_1 happy_var_3 (fst happy_var_4) (reverse gs) happy_var_6) })}}}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_100 = happyMonadReduce 4# 39# happyReduction_100+happyReduction_100 (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 { (Loc happy_var_1 KW_Class) -> + case happyOut89 happy_x_2 of { happy_var_2 -> + case happyOut97 happy_x_3 of { happy_var_3 -> + case happyOut123 happy_x_4 of { happy_var_4 -> + ( do { (cs,dh) <- checkClassHeader happy_var_2;+ let {(fds,ss1,minf1) = happy_var_3;(mcs,ss2,minf2) = happy_var_4} ;+ let { l = nIS happy_var_1 <++> ann happy_var_2 <+?> minf1 <+?> minf2 <** (happy_var_1:ss1 ++ ss2)} ;+ return (ClassDecl l cs dh fds mcs) })}}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_101 = happyMonadReduce 3# 39# happyReduction_101+happyReduction_101 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> + case happyOut89 happy_x_2 of { happy_var_2 -> + case happyOut128 happy_x_3 of { happy_var_3 -> + ( do { (cs,ih) <- checkInstHeader happy_var_2;+ let {(mis,ss,minf) = happy_var_3};+ return (InstDecl (nIS happy_var_1 <++> ann happy_var_2 <+?> minf <** (happy_var_1:ss)) cs ih mis) })}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_102 = happyMonadReduce 3# 39# happyReduction_102+happyReduction_102 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + ( do { checkEnabled StandaloneDeriving ;+ (cs, ih) <- checkInstHeader happy_var_3;+ let {l = nIS happy_var_1 <++> ann happy_var_3 <** [happy_var_1,happy_var_2]};+ return (DerivDecl l cs ih) })}}}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_103 = happyReduce 4# 39# happyReduction_103+happyReduction_103 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn50+ (DefaultDecl (happy_var_1 <^^> happy_var_4 <** (happy_var_1:happy_var_2 : snd happy_var_3 ++ [happy_var_4])) (fst happy_var_3)+ ) `HappyStk` happyRest}}}}++happyReduce_104 = happyMonadReduce 1# 39# happyReduction_104+happyReduction_104 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut141 happy_x_1 of { happy_var_1 -> + ( checkEnabled TemplateHaskell >> checkExpr happy_var_1 >>= \e -> return (SpliceDecl (ann e) e))}+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_105 = happyReduce 5# 39# happyReduction_105+happyReduction_105 (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 { (Loc happy_var_1 KW_Foreign) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Import) -> + case happyOut63 happy_x_3 of { happy_var_3 -> + case happyOut64 happy_x_4 of { happy_var_4 -> + case happyOut65 happy_x_5 of { happy_var_5 -> + happyIn50+ (let (s,n,t,ss) = happy_var_5 in ForImp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3 happy_var_4 s n t+ ) `HappyStk` happyRest}}}}}++happyReduce_106 = happyReduce 4# 39# happyReduction_106+happyReduction_106 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Export) -> + case happyOut63 happy_x_3 of { happy_var_3 -> + case happyOut65 happy_x_4 of { happy_var_4 -> + happyIn50+ (let (s,n,t,ss) = happy_var_4 in ForExp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3 s n t+ ) `HappyStk` happyRest}}}}++happyReduce_107 = happySpecReduce_3 39# happyReduction_107+happyReduction_107 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 RULES) -> + case happyOut66 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn50+ (RulePragmaDecl (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ reverse happy_var_2+ )}}}++happyReduce_108 = happySpecReduce_3 39# happyReduction_108+happyReduction_108 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn50+ (DeprPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)+ )}}}++happyReduce_109 = happySpecReduce_3 39# happyReduction_109+happyReduction_109 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn50+ (WarnPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)+ )}}}++happyReduce_110 = happySpecReduce_3 39# happyReduction_110+happyReduction_110 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + happyIn50+ (AnnPragma (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_111 = happySpecReduce_1 39# happyReduction_111+happyReduction_111 happy_x_1+ = case happyOut55 happy_x_1 of { happy_var_1 -> + happyIn50+ (happy_var_1+ )}++happyReduce_112 = happySpecReduce_1 40# happyReduction_112+happyReduction_112 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> + happyIn51+ (DataType $ nIS happy_var_1+ )}++happyReduce_113 = happySpecReduce_1 40# happyReduction_113+happyReduction_113 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> + happyIn51+ (NewType $ nIS happy_var_1+ )}++happyReduce_114 = happyMonadReduce 1# 41# happyReduction_114+happyReduction_114 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut91 happy_x_1 of { happy_var_1 -> + ( do { ts <- mapM checkType (fst happy_var_1);+ return $ (reverse ts, reverse (snd happy_var_1)) })}+ ) (\r -> happyReturn (happyIn52 r))++happyReduce_115 = happySpecReduce_1 41# happyReduction_115+happyReduction_115 happy_x_1+ = case happyOut79 happy_x_1 of { happy_var_1 -> + happyIn52+ (([happy_var_1],[])+ )}++happyReduce_116 = happySpecReduce_0 41# happyReduction_116+happyReduction_116 = happyIn52+ (([],[])+ )++happyReduce_117 = happyMonadReduce 3# 42# happyReduction_117+happyReduction_117 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut54 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + ( checkRevDecls (fst happy_var_2) >>= \ds -> return (ds, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+ ) (\r -> happyReturn (happyIn53 r))++happyReduce_118 = happySpecReduce_1 42# happyReduction_118+happyReduction_118 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn53+ (([],reverse happy_var_1)+ )}++happyReduce_119 = happySpecReduce_3 43# happyReduction_119+happyReduction_119 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn54+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_120 = happySpecReduce_1 43# happyReduction_120+happyReduction_120 happy_x_1+ = case happyOut55 happy_x_1 of { happy_var_1 -> + happyIn54+ (([happy_var_1],[])+ )}++happyReduce_121 = happySpecReduce_1 44# happyReduction_121+happyReduction_121 happy_x_1+ = case happyOut57 happy_x_1 of { happy_var_1 -> + happyIn55+ (happy_var_1+ )}++happyReduce_122 = happySpecReduce_1 44# happyReduction_122+happyReduction_122 happy_x_1+ = case happyOut44 happy_x_1 of { happy_var_1 -> + happyIn55+ (happy_var_1+ )}++happyReduce_123 = happySpecReduce_1 44# happyReduction_123+happyReduction_123 happy_x_1+ = case happyOut133 happy_x_1 of { happy_var_1 -> + happyIn55+ (happy_var_1+ )}++happyReduce_124 = happySpecReduce_3 45# happyReduction_124+happyReduction_124 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> + case happyOut53 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + happyIn56+ (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)+ )}}}++happyReduce_125 = happySpecReduce_3 45# happyReduction_125+happyReduction_125 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn56+ (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)+ )}}}++happyReduce_126 = happyMonadReduce 3# 46# happyReduction_126+happyReduction_126 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut88 happy_x_3 of { happy_var_3 -> + ( do { v <- checkSigVar happy_var_1;+ return $ TypeSig (happy_var_1 <> happy_var_3 <** [happy_var_2]) [v] happy_var_3 })}}}+ ) (\r -> happyReturn (happyIn57 r))++happyReduce_127 = happyMonadReduce 5# 46# happyReduction_127+happyReduction_127 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut62 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> + case happyOut88 happy_x_5 of { happy_var_5 -> + ( do { v <- checkSigVar happy_var_1;+ let {(vs,ss,_) = happy_var_3 ; l = happy_var_1 <> happy_var_5 <** (happy_var_2 : reverse ss ++ [happy_var_4]) } ;+ return $ TypeSig l (v : reverse vs) happy_var_5 })}}}}}+ ) (\r -> happyReturn (happyIn57 r))++happyReduce_128 = happySpecReduce_1 46# happyReduction_128+happyReduction_128 happy_x_1+ = case happyOut58 happy_x_1 of { happy_var_1 -> + happyIn57+ (happy_var_1+ )}++happyReduce_129 = happyReduce 4# 47# happyReduction_129+happyReduction_129 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut195 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> + happyIn58+ (let Loc l (INLINE s) = happy_var_1 in InlineSig (l <^^> happy_var_4 <** [l,happy_var_4]) s happy_var_2 happy_var_3+ ) `HappyStk` happyRest}}}}++happyReduce_130 = happyReduce 4# 47# happyReduction_130+happyReduction_130 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 INLINE_CONLIKE) -> + case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut195 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> + happyIn58+ (InlineConlikeSig (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_4]) happy_var_2 happy_var_3+ ) `HappyStk` happyRest}}}}++happyReduce_131 = happyReduce 5# 47# happyReduction_131+happyReduction_131 (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 { (Loc happy_var_1 SPECIALISE) -> + case happyOut195 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> + case happyOut59 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 PragmaEnd) -> + happyIn58+ (SpecSig (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3 : snd happy_var_4 ++ [happy_var_5])) happy_var_2 (fst happy_var_4)+ ) `HappyStk` happyRest}}}}}++happyReduce_132 = happyReduce 6# 47# happyReduction_132+happyReduction_132 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut195 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> + case happyOut59 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { (Loc happy_var_6 PragmaEnd) -> + happyIn58+ (let Loc l (SPECIALISE_INLINE s) = happy_var_1+ in SpecInlineSig (l <^^> happy_var_6 <** (l:happy_var_4:snd happy_var_5++[happy_var_6])) s happy_var_2 happy_var_3 (fst happy_var_5)+ ) `HappyStk` happyRest}}}}}}++happyReduce_133 = happyMonadReduce 4# 47# happyReduction_133+happyReduction_133 (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 { (Loc happy_var_1 SPECIALISE) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> + ( do { (cs,ih) <- checkInstHeader happy_var_3;+ let {l = happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,happy_var_4]};+ return $ InstSig l cs ih })}}}}+ ) (\r -> happyReturn (happyIn58 r))++happyReduce_134 = happySpecReduce_1 48# happyReduction_134+happyReduction_134 happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + happyIn59+ (([happy_var_1],[])+ )}++happyReduce_135 = happySpecReduce_3 48# happyReduction_135+happyReduction_135 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut59 happy_x_3 of { happy_var_3 -> + happyIn59+ ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+ )}}}++happyReduce_136 = happyMonadReduce 1# 49# happyReduction_136+happyReduction_136 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> + ( checkType $ mkTyForall (ann happy_var_1) Nothing Nothing happy_var_1)}+ ) (\r -> happyReturn (happyIn60 r))++happyReduce_137 = happySpecReduce_1 50# happyReduction_137+happyReduction_137 happy_x_1+ = case happyOut56 happy_x_1 of { happy_var_1 -> + happyIn61+ (happy_var_1+ )}++happyReduce_138 = happySpecReduce_3 50# happyReduction_138+happyReduction_138 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> + case happyOut189 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + happyIn61+ (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)+ )}}}++happyReduce_139 = happySpecReduce_3 50# happyReduction_139+happyReduction_139 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut189 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn61+ (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)+ )}}}++happyReduce_140 = happySpecReduce_3 51# happyReduction_140+happyReduction_140 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut193 happy_x_3 of { happy_var_3 -> + happyIn62+ (let (ns,ss,l) = happy_var_1 in (happy_var_3 : ns, happy_var_2 : ss, l <++> ann happy_var_3)+ )}}}++happyReduce_141 = happyMonadReduce 1# 51# happyReduction_141+happyReduction_141 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut195 happy_x_1 of { happy_var_1 -> + ( do { n <- checkUnQual happy_var_1;+ return ([n],[],ann n) })}+ ) (\r -> happyReturn (happyIn62 r))++happyReduce_142 = happySpecReduce_1 52# happyReduction_142+happyReduction_142 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> + happyIn63+ (StdCall (nIS happy_var_1)+ )}++happyReduce_143 = happySpecReduce_1 52# happyReduction_143+happyReduction_143 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> + happyIn63+ (CCall (nIS happy_var_1)+ )}++happyReduce_144 = happySpecReduce_1 53# happyReduction_144+happyReduction_144 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> + happyIn64+ (Just $ PlaySafe (nIS happy_var_1) False+ )}++happyReduce_145 = happySpecReduce_1 53# happyReduction_145+happyReduction_145 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> + happyIn64+ (Just $ PlayRisky (nIS happy_var_1)+ )}++happyReduce_146 = happySpecReduce_1 53# happyReduction_146+happyReduction_146 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> + happyIn64+ (Just $ PlaySafe (nIS happy_var_1) True+ )}++happyReduce_147 = happySpecReduce_0 53# happyReduction_147+happyReduction_147 = happyIn64+ (Nothing+ )++happyReduce_148 = happyReduce 4# 54# happyReduction_148+happyReduction_148 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut194 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> + case happyOut77 happy_x_4 of { happy_var_4 -> + happyIn65+ (let Loc l (StringTok (s,_)) = happy_var_1 in (Just s, happy_var_2, happy_var_4, [l,happy_var_3])+ ) `HappyStk` happyRest}}}}++happyReduce_149 = happySpecReduce_3 54# happyReduction_149+happyReduction_149 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut194 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut77 happy_x_3 of { happy_var_3 -> + happyIn65+ ((Nothing, happy_var_1, happy_var_3, [happy_var_2])+ )}}}++happyReduce_150 = happySpecReduce_3 55# happyReduction_150+happyReduction_150 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut67 happy_x_3 of { happy_var_3 -> + happyIn66+ (happy_var_3 : happy_var_1+ )}}++happyReduce_151 = happySpecReduce_2 55# happyReduction_151+happyReduction_151 happy_x_2+ happy_x_1+ = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn66+ (happy_var_1+ )}++happyReduce_152 = happySpecReduce_1 55# happyReduction_152+happyReduction_152 happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn66+ ([happy_var_1]+ )}++happyReduce_153 = happySpecReduce_0 55# happyReduction_153+happyReduction_153 = happyIn66+ ([]+ )++happyReduce_154 = happyMonadReduce 6# 56# happyReduction_154+happyReduction_154 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + case happyOut141 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 Equals) -> + case happyOut139 happy_x_6 of { happy_var_6 -> + ( do { let {Loc l (StringTok (s,_)) = happy_var_1};+ e <- checkRuleExpr happy_var_4;+ return $ Rule (nIS l <++> ann happy_var_6 <** l:snd happy_var_3 ++ [happy_var_5]) s happy_var_2 (fst happy_var_3) e happy_var_6 })}}}}}}+ ) (\r -> happyReturn (happyIn67 r))++happyReduce_155 = happySpecReduce_0 57# happyReduction_155+happyReduction_155 = happyIn68+ (Nothing+ )++happyReduce_156 = happySpecReduce_3 57# happyReduction_156+happyReduction_156 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> + happyIn68+ (let Loc l (IntTok (i,_)) = happy_var_2 in Just $ ActiveFrom (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) (fromInteger i)+ )}}}++happyReduce_157 = happyReduce 4# 57# happyReduction_157+happyReduction_157 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightSquare) -> + happyIn68+ (let Loc l (IntTok (i,_)) = happy_var_3 in Just $ ActiveUntil (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,l,happy_var_4]) (fromInteger i)+ ) `HappyStk` happyRest}}}}++happyReduce_158 = happySpecReduce_0 58# happyReduction_158+happyReduction_158 = happyIn69+ ((Nothing,[])+ )++happyReduce_159 = happySpecReduce_3 58# happyReduction_159+happyReduction_159 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> + case happyOut70 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> + happyIn69+ ((Just happy_var_2,[happy_var_1,happy_var_3])+ )}}}++happyReduce_160 = happySpecReduce_1 59# happyReduction_160+happyReduction_160 happy_x_1+ = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn70+ ([happy_var_1]+ )}++happyReduce_161 = happySpecReduce_2 59# happyReduction_161+happyReduction_161 happy_x_2+ happy_x_1+ = case happyOut71 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_2 of { happy_var_2 -> + happyIn70+ (happy_var_1 : happy_var_2+ )}}++happyReduce_162 = happySpecReduce_1 60# happyReduction_162+happyReduction_162 happy_x_1+ = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn71+ (RuleVar (ann happy_var_1) happy_var_1+ )}++happyReduce_163 = happyReduce 5# 60# happyReduction_163+happyReduction_163 (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 { (Loc happy_var_1 LeftParen) -> + case happyOut210 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> + case happyOut88 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> + happyIn71+ (TypedRuleVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_164 = happySpecReduce_3 61# happyReduction_164+happyReduction_164 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn72+ ((fst happy_var_3 : fst happy_var_1, snd happy_var_1 ++ (happy_var_2:snd happy_var_3))+ )}}}++happyReduce_165 = happySpecReduce_2 61# happyReduction_165+happyReduction_165 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> + happyIn72+ ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2])+ )}}++happyReduce_166 = happySpecReduce_1 61# happyReduction_166+happyReduction_166 happy_x_1+ = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn72+ (([fst happy_var_1],snd happy_var_1)+ )}++happyReduce_167 = happySpecReduce_0 61# happyReduction_167+happyReduction_167 = happyIn72+ (([],[])+ )++happyReduce_168 = happySpecReduce_2 62# happyReduction_168+happyReduction_168 happy_x_2+ happy_x_1+ = case happyOut74 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn73+ (let Loc l (StringTok (s,_)) = happy_var_2 in ((fst happy_var_1,s),snd happy_var_1 ++ [l])+ )}}++happyReduce_169 = happySpecReduce_1 63# happyReduction_169+happyReduction_169 happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + happyIn74+ (([happy_var_1],[])+ )}++happyReduce_170 = happySpecReduce_3 63# happyReduction_170+happyReduction_170 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn74+ ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+ )}}}++happyReduce_171 = happySpecReduce_1 64# happyReduction_171+happyReduction_171 happy_x_1+ = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn75+ (happy_var_1+ )}++happyReduce_172 = happySpecReduce_1 64# happyReduction_172+happyReduction_172 happy_x_1+ = case happyOut193 happy_x_1 of { happy_var_1 -> + happyIn75+ (happy_var_1+ )}++happyReduce_173 = happyMonadReduce 3# 65# happyReduction_173+happyReduction_173 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> + case happyOut213 happy_x_2 of { happy_var_2 -> + case happyOut150 happy_x_3 of { happy_var_3 -> + ( checkExpr happy_var_3 >>= \e -> return (TypeAnn (nIS happy_var_1 <++> ann e <** [happy_var_1]) happy_var_2 e))}}}+ ) (\r -> happyReturn (happyIn76 r))++happyReduce_174 = happyMonadReduce 2# 65# happyReduction_174+happyReduction_174 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> + case happyOut150 happy_x_2 of { happy_var_2 -> + ( checkExpr happy_var_2 >>= \e -> return (ModuleAnn (nIS happy_var_1 <++> ann e <** [happy_var_1]) e))}}+ ) (\r -> happyReturn (happyIn76 r))++happyReduce_175 = happyMonadReduce 2# 65# happyReduction_175+happyReduction_175 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_2 of { happy_var_2 -> + ( checkExpr happy_var_2 >>= \e -> return (Ann (happy_var_1 <> e) happy_var_1 e))}}+ ) (\r -> happyReturn (happyIn76 r))++happyReduce_176 = happyMonadReduce 1# 66# happyReduction_176+happyReduction_176 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut78 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)}+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_177 = happySpecReduce_1 67# happyReduction_177+happyReduction_177 happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + happyIn78+ (happy_var_1+ )}++happyReduce_178 = happySpecReduce_3 67# happyReduction_178+happyReduction_178 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_2 of { happy_var_2 -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn78+ (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+ )}}}++happyReduce_179 = happySpecReduce_3 67# happyReduction_179+happyReduction_179 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOut228 happy_x_2 of { happy_var_2 -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn78+ (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+ )}}}++happyReduce_180 = happySpecReduce_3 67# happyReduction_180+happyReduction_180 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + happyIn78+ (TyFun (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_181 = happyMonadReduce 3# 67# happyReduction_181+happyReduction_181 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> + case happyOut82 happy_x_3 of { happy_var_3 -> + ( do { checkEnabled TypeFamilies ;+ let {l = happy_var_1 <> happy_var_3 <** [happy_var_2]};+ return $ TyPred l $ EqualP l happy_var_1 happy_var_3 })}}}+ ) (\r -> happyReturn (happyIn78 r))++happyReduce_182 = happyMonadReduce 1# 68# happyReduction_182+happyReduction_182 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut80 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)}+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_183 = happySpecReduce_3 69# happyReduction_183+happyReduction_183 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut196 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn80+ (let l = (happy_var_1 <> happy_var_3 <** [happy_var_2]) in TyPred l $ IParam l happy_var_1 happy_var_3+ )}}}++happyReduce_184 = happySpecReduce_1 69# happyReduction_184+happyReduction_184 happy_x_1+ = case happyOut78 happy_x_1 of { happy_var_1 -> + happyIn80+ (happy_var_1+ )}++happyReduce_185 = happyMonadReduce 1# 70# happyReduction_185+happyReduction_185 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)}+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_186 = happySpecReduce_2 71# happyReduction_186+happyReduction_186 happy_x_2+ happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + happyIn82+ (TyApp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+ )}}++happyReduce_187 = happySpecReduce_1 71# happyReduction_187+happyReduction_187 happy_x_1+ = case happyOut84 happy_x_1 of { happy_var_1 -> + happyIn82+ (happy_var_1+ )}++happyReduce_188 = happyMonadReduce 1# 72# happyReduction_188+happyReduction_188 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut84 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)}+ ) (\r -> happyReturn (happyIn83 r))++happyReduce_189 = happySpecReduce_1 73# happyReduction_189+happyReduction_189 happy_x_1+ = case happyOut85 happy_x_1 of { happy_var_1 -> + happyIn84+ (TyCon (ann happy_var_1) happy_var_1+ )}++happyReduce_190 = happySpecReduce_1 73# happyReduction_190+happyReduction_190 happy_x_1+ = case happyOut227 happy_x_1 of { happy_var_1 -> + happyIn84+ (TyVar (ann happy_var_1) happy_var_1+ )}++happyReduce_191 = happySpecReduce_3 73# happyReduction_191+happyReduction_191 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut91 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn84+ (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Boxed (reverse (fst happy_var_2))+ )}}}++happyReduce_192 = happySpecReduce_3 73# happyReduction_192+happyReduction_192 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> + case happyOut92 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> + happyIn84+ (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Unboxed (reverse (fst happy_var_2))+ )}}}++happyReduce_193 = happySpecReduce_3 73# happyReduction_193+happyReduction_193 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOut80 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> + happyIn84+ (TyList (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_194 = happySpecReduce_3 73# happyReduction_194+happyReduction_194 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut89 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn84+ (TyParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_195 = happyReduce 5# 73# happyReduction_195+happyReduction_195 (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 { (Loc happy_var_1 LeftParen) -> + case happyOut89 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> + case happyOut119 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> + happyIn84+ (TyKind (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_196 = happySpecReduce_1 74# happyReduction_196+happyReduction_196 happy_x_1+ = case happyOut86 happy_x_1 of { happy_var_1 -> + happyIn85+ (happy_var_1+ )}++happyReduce_197 = happySpecReduce_2 74# happyReduction_197+happyReduction_197 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> + happyIn85+ (unit_tycon_name (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+ )}}++happyReduce_198 = happySpecReduce_3 74# happyReduction_198+happyReduction_198 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn85+ (fun_tycon_name (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3])+ )}}}++happyReduce_199 = happySpecReduce_2 74# happyReduction_199+happyReduction_199 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> + happyIn85+ (list_tycon_name (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+ )}}++happyReduce_200 = happySpecReduce_3 74# happyReduction_200+happyReduction_200 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn85+ (tuple_tycon_name (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Boxed (length happy_var_2)+ )}}}++happyReduce_201 = happySpecReduce_2 74# happyReduction_201+happyReduction_201 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> + happyIn85+ (unboxed_singleton_tycon_name (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+ )}}++happyReduce_202 = happySpecReduce_3 74# happyReduction_202+happyReduction_202 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> + happyIn85+ (tuple_tycon_name (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Unboxed (length happy_var_2)+ )}}}++happyReduce_203 = happySpecReduce_1 75# happyReduction_203+happyReduction_203 happy_x_1+ = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn86+ (happy_var_1+ )}++happyReduce_204 = happySpecReduce_3 75# happyReduction_204+happyReduction_204 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut207 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn86+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_205 = happySpecReduce_3 75# happyReduction_205+happyReduction_205 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn86+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_206 = happySpecReduce_1 76# happyReduction_206+happyReduction_206 happy_x_1+ = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn87+ (happy_var_1+ )}++happyReduce_207 = happyMonadReduce 1# 77# happyReduction_207+happyReduction_207 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)}+ ) (\r -> happyReturn (happyIn88 r))++happyReduce_208 = happyReduce 4# 78# happyReduction_208+happyReduction_208 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> + case happyOut93 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> + case happyOut89 happy_x_4 of { happy_var_4 -> + happyIn89+ (TyForall (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (Just (reverse (fst happy_var_2))) Nothing happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_209 = happySpecReduce_2 78# happyReduction_209+happyReduction_209 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+ (TyForall (happy_var_1 <> happy_var_2) Nothing (Just happy_var_1) happy_var_2+ )}}++happyReduce_210 = happySpecReduce_1 78# happyReduction_210+happyReduction_210 happy_x_1+ = case happyOut80 happy_x_1 of { happy_var_1 -> + happyIn89+ (happy_var_1+ )}++happyReduce_211 = happyMonadReduce 2# 79# happyReduction_211+happyReduction_211 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleArrow) -> + ( checkPContext $ (amap (\l -> l <++> nIS happy_var_2 <** (srcInfoPoints l ++ [happy_var_2]))) happy_var_1)}}+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_212 = happyMonadReduce 4# 79# happyReduction_212+happyReduction_212 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleArrow) -> + ( do { checkEnabled TypeFamilies;+ let {l = happy_var_1 <> happy_var_3 <** [happy_var_2,happy_var_4]};+ checkPContext (TyPred l $ EqualP l happy_var_1 happy_var_3) })}}}}+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_213 = happySpecReduce_3 80# happyReduction_213+happyReduction_213 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut92 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + happyIn91+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_214 = happySpecReduce_1 81# happyReduction_214+happyReduction_214 happy_x_1+ = case happyOut89 happy_x_1 of { happy_var_1 -> + happyIn92+ (([happy_var_1],[])+ )}++happyReduce_215 = happySpecReduce_3 81# happyReduction_215+happyReduction_215 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut92 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut89 happy_x_3 of { happy_var_3 -> + happyIn92+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_216 = happySpecReduce_2 82# happyReduction_216+happyReduction_216 happy_x_2+ happy_x_1+ = case happyOut93 happy_x_1 of { happy_var_1 -> + case happyOut94 happy_x_2 of { happy_var_2 -> + happyIn93+ ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))+ )}}++happyReduce_217 = happySpecReduce_0 82# happyReduction_217+happyReduction_217 = happyIn93+ (([],Nothing)+ )++happyReduce_218 = happySpecReduce_1 83# happyReduction_218+happyReduction_218 happy_x_1+ = case happyOut227 happy_x_1 of { happy_var_1 -> + happyIn94+ (UnkindedVar (ann happy_var_1) happy_var_1+ )}++happyReduce_219 = happyReduce 5# 83# happyReduction_219+happyReduction_219 (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 { (Loc happy_var_1 LeftParen) -> + case happyOut227 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> + case happyOut119 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> + happyIn94+ (KindedVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_220 = happySpecReduce_2 84# happyReduction_220+happyReduction_220 happy_x_2+ happy_x_1+ = case happyOut95 happy_x_1 of { happy_var_1 -> + case happyOut227 happy_x_2 of { happy_var_2 -> + happyIn95+ ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))+ )}}++happyReduce_221 = happySpecReduce_0 84# happyReduction_221+happyReduction_221 = happyIn95+ (([], Nothing)+ )++happyReduce_222 = happySpecReduce_2 85# happyReduction_222+happyReduction_222 happy_x_2+ happy_x_1+ = case happyOut95 happy_x_1 of { happy_var_1 -> + case happyOut227 happy_x_2 of { happy_var_2 -> + happyIn96+ ((happy_var_2 : fst happy_var_1, snd happy_var_1 <?+> ann happy_var_2)+ )}}++happyReduce_223 = happySpecReduce_0 86# happyReduction_223+happyReduction_223 = happyIn97+ (([],[], Nothing)+ )++happyReduce_224 = happyMonadReduce 2# 86# happyReduction_224+happyReduction_224 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Bar) -> + case happyOut98 happy_x_2 of { happy_var_2 -> + ( do { checkEnabled FunctionalDependencies ;+ let {(fds,ss,l) = happy_var_2} ;+ return (reverse fds, happy_var_1 : reverse ss, Just (nIS happy_var_1 <++> l)) })}}+ ) (\r -> happyReturn (happyIn97 r))++happyReduce_225 = happySpecReduce_3 87# happyReduction_225+happyReduction_225 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut98 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut99 happy_x_3 of { happy_var_3 -> + happyIn98+ (let (fds,ss,l) = happy_var_1 in (happy_var_3 : fds, happy_var_2 : ss, l <++> ann happy_var_3)+ )}}}++happyReduce_226 = happySpecReduce_1 87# happyReduction_226+happyReduction_226 happy_x_1+ = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn98+ (([happy_var_1],[],ann happy_var_1)+ )}++happyReduce_227 = happySpecReduce_3 88# happyReduction_227+happyReduction_227 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut96 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> + case happyOut96 happy_x_3 of { happy_var_3 -> + happyIn99+ (FunDep (snd happy_var_1 <++> snd happy_var_3 <** [happy_var_2]) (reverse (fst happy_var_1)) (reverse (fst happy_var_3))+ )}}}++happyReduce_228 = happyMonadReduce 4# 89# happyReduction_228+happyReduction_228 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOut101 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> + ( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}+ ) (\r -> happyReturn (happyIn100 r))++happyReduce_229 = happyMonadReduce 4# 89# happyReduction_229+happyReduction_229 (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 { (Loc happy_var_1 KW_Where) -> + case happyOut222 happy_x_2 of { happy_var_2 -> + case happyOut101 happy_x_3 of { happy_var_3 -> + case happyOut223 happy_x_4 of { happy_var_4 -> + ( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}+ ) (\r -> happyReturn (happyIn100 r))++happyReduce_230 = happyMonadReduce 0# 89# happyReduction_230+happyReduction_230 (happyRest) tk+ = happyThen (( checkEnabled EmptyDataDecls >> return ([],[],Nothing))+ ) (\r -> happyReturn (happyIn100 r))++happyReduce_231 = happySpecReduce_3 90# happyReduction_231+happyReduction_231 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut102 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn101+ ((fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+ )}}}++happyReduce_232 = happySpecReduce_3 91# happyReduction_232+happyReduction_232 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut102 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + happyIn102+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_233 = happySpecReduce_1 91# happyReduction_233+happyReduction_233 happy_x_1+ = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn102+ (([happy_var_1],[])+ )}++happyReduce_234 = happyMonadReduce 3# 92# happyReduction_234+happyReduction_234 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut88 happy_x_3 of { happy_var_3 -> + ( do { c <- checkUnQual happy_var_1;+ return $ GadtDecl (happy_var_1 <> happy_var_3 <** [happy_var_2]) c happy_var_3 })}}}+ ) (\r -> happyReturn (happyIn103 r))++happyReduce_235 = happySpecReduce_2 93# happyReduction_235+happyReduction_235 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> + case happyOut105 happy_x_2 of { happy_var_2 -> + happyIn104+ (let (ds,ss,l) = happy_var_2 in (ds, happy_var_1 : reverse ss, Just $ nIS happy_var_1 <++> l)+ )}}++happyReduce_236 = happySpecReduce_3 94# happyReduction_236+happyReduction_236 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut105 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> + case happyOut106 happy_x_3 of { happy_var_3 -> + happyIn105+ (let (ds,ss,l) = happy_var_1 in (happy_var_3 : ds, happy_var_2 : ss, l <++> ann happy_var_3)+ )}}}++happyReduce_237 = happySpecReduce_1 94# happyReduction_237+happyReduction_237 happy_x_1+ = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn105+ (([happy_var_1],[],ann happy_var_1)+ )}++happyReduce_238 = happyMonadReduce 3# 95# happyReduction_238+happyReduction_238 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut90 happy_x_2 of { happy_var_2 -> + case happyOut108 happy_x_3 of { happy_var_3 -> + ( do { checkEnabled ExistentialQuantification ;+ ctxt <- checkContext (Just happy_var_2) ;+ let {(mtvs,ss,ml) = happy_var_1} ;+ return $ QualConDecl (ml <?+> ann happy_var_3 <** ss) mtvs ctxt happy_var_3 })}}}+ ) (\r -> happyReturn (happyIn106 r))++happyReduce_239 = happySpecReduce_2 95# happyReduction_239+happyReduction_239 happy_x_2+ happy_x_1+ = case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_2 of { happy_var_2 -> + happyIn106+ (let (mtvs, ss, ml) = happy_var_1 in QualConDecl (ml <?+> ann happy_var_2 <** ss) mtvs Nothing happy_var_2+ )}}++happyReduce_240 = happyMonadReduce 3# 96# happyReduction_240+happyReduction_240 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> + case happyOut93 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> + ( checkEnabled ExistentialQuantification >> return (Just (fst happy_var_2), [happy_var_1,happy_var_3], Just $ happy_var_1 <^^> happy_var_3))}}}+ ) (\r -> happyReturn (happyIn107 r))++happyReduce_241 = happySpecReduce_0 96# happyReduction_241+happyReduction_241 = happyIn107+ ((Nothing, [], Nothing)+ )++happyReduce_242 = happySpecReduce_1 97# happyReduction_242+happyReduction_242 happy_x_1+ = case happyOut109 happy_x_1 of { happy_var_1 -> + happyIn108+ (let (n,ts,l) = happy_var_1 in ConDecl l n ts+ )}++happyReduce_243 = happySpecReduce_3 97# happyReduction_243+happyReduction_243 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut112 happy_x_1 of { happy_var_1 -> + case happyOut202 happy_x_2 of { happy_var_2 -> + case happyOut112 happy_x_3 of { happy_var_3 -> + happyIn108+ (InfixConDecl (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+ )}}}++happyReduce_244 = happyMonadReduce 3# 97# happyReduction_244+happyReduction_244 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + ( do { c <- checkUnQual happy_var_1; return $ RecDecl (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]) c [] })}}}+ ) (\r -> happyReturn (happyIn108 r))++happyReduce_245 = happyMonadReduce 4# 97# happyReduction_245+happyReduction_245 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOut113 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> + ( do { c <- checkUnQual happy_var_1;+ return $ RecDecl (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) c (reverse (fst happy_var_3)) })}}}}+ ) (\r -> happyReturn (happyIn108 r))++happyReduce_246 = happyMonadReduce 1# 98# happyReduction_246+happyReduction_246 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + ( do { (c,ts) <- splitTyConApp happy_var_1;+ return (c,map (\t -> UnBangedTy (ann t) t) ts,ann happy_var_1) })}+ ) (\r -> happyReturn (happyIn109 r))++happyReduce_247 = happySpecReduce_1 98# happyReduction_247+happyReduction_247 happy_x_1+ = case happyOut110 happy_x_1 of { happy_var_1 -> + happyIn109+ (happy_var_1+ )}++happyReduce_248 = happyMonadReduce 3# 99# happyReduction_248+happyReduction_248 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Exclamation) -> + case happyOut83 happy_x_3 of { happy_var_3 -> + ( do { (c,ts) <- splitTyConApp happy_var_1;+ return (c,map (\t -> UnBangedTy (ann t) t) ts+++ [BangedTy (nIS happy_var_2 <++> ann happy_var_3 <** [happy_var_2]) happy_var_3], happy_var_1 <> happy_var_3) })}}}+ ) (\r -> happyReturn (happyIn110 r))++happyReduce_249 = happyMonadReduce 5# 99# happyReduction_249+happyReduction_249 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 UNPACK) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 Exclamation) -> + case happyOut83 happy_x_5 of { happy_var_5 -> + ( do { (c,ts) <- splitTyConApp happy_var_1;+ return (c,map (\t -> UnBangedTy (ann t) t) ts+++ [UnpackedTy (nIS happy_var_2 <++> ann happy_var_5 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_5], happy_var_1 <> happy_var_5) })}}}}}+ ) (\r -> happyReturn (happyIn110 r))++happyReduce_250 = happySpecReduce_2 99# happyReduction_250+happyReduction_250 happy_x_2+ happy_x_1+ = case happyOut110 happy_x_1 of { happy_var_1 -> + case happyOut111 happy_x_2 of { happy_var_2 -> + happyIn110+ (let (n,ts,l) = happy_var_1 in (n, ts ++ [happy_var_2],l <++> ann happy_var_2)+ )}}++happyReduce_251 = happySpecReduce_1 100# happyReduction_251+happyReduction_251 happy_x_1+ = case happyOut83 happy_x_1 of { happy_var_1 -> + happyIn111+ (UnBangedTy (ann happy_var_1) happy_var_1+ )}++happyReduce_252 = happySpecReduce_2 100# happyReduction_252+happyReduction_252 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + case happyOut83 happy_x_2 of { happy_var_2 -> + happyIn111+ (BangedTy (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_253 = happyReduce 4# 100# happyReduction_253+happyReduction_253 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn111+ (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_254 = happySpecReduce_1 101# happyReduction_254+happyReduction_254 happy_x_1+ = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn112+ (UnBangedTy (ann happy_var_1) happy_var_1+ )}++happyReduce_255 = happySpecReduce_2 101# happyReduction_255+happyReduction_255 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + case happyOut83 happy_x_2 of { happy_var_2 -> + happyIn112+ (BangedTy (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_256 = happyReduce 4# 101# happyReduction_256+happyReduction_256 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn112+ (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_257 = happySpecReduce_3 102# happyReduction_257+happyReduction_257 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut114 happy_x_3 of { happy_var_3 -> + happyIn113+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_258 = happySpecReduce_1 102# happyReduction_258+happyReduction_258 happy_x_1+ = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn113+ (([happy_var_1],[])+ )}++happyReduce_259 = happySpecReduce_3 103# happyReduction_259+happyReduction_259 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut115 happy_x_3 of { happy_var_3 -> + happyIn114+ (let (ns,ss,l) = happy_var_1 in FieldDecl (l <++> ann happy_var_3 <** (reverse ss ++ [happy_var_2])) (reverse ns) happy_var_3+ )}}}++happyReduce_260 = happySpecReduce_1 104# happyReduction_260+happyReduction_260 happy_x_1+ = case happyOut88 happy_x_1 of { happy_var_1 -> + happyIn115+ (UnBangedTy (ann happy_var_1) happy_var_1+ )}++happyReduce_261 = happySpecReduce_2 104# happyReduction_261+happyReduction_261 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + case happyOut83 happy_x_2 of { happy_var_2 -> + happyIn115+ (BangedTy (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_262 = happyReduce 4# 104# happyReduction_262+happyReduction_262 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn115+ (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_263 = happySpecReduce_0 105# happyReduction_263+happyReduction_263 = happyIn116+ (Nothing+ )++happyReduce_264 = happySpecReduce_2 105# happyReduction_264+happyReduction_264 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> + case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn116+ (let l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] in Just $ Deriving l [IHead (ann happy_var_2) happy_var_2 []]+ )}}++happyReduce_265 = happySpecReduce_3 105# happyReduction_265+happyReduction_265 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn116+ (Just $ Deriving (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3]) []+ )}}}++happyReduce_266 = happyReduce 4# 105# happyReduction_266+happyReduction_266 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn116+ (Just $ Deriving (happy_var_1 <^^> happy_var_4 <** happy_var_1:happy_var_2: reverse (snd happy_var_3) ++ [happy_var_4]) (reverse (fst happy_var_3))+ ) `HappyStk` happyRest}}}}++happyReduce_267 = happyMonadReduce 1# 106# happyReduction_267+happyReduction_267 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut92 happy_x_1 of { happy_var_1 -> + ( checkDeriving (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1))}+ ) (\r -> happyReturn (happyIn117 r))++happyReduce_268 = happySpecReduce_1 107# happyReduction_268+happyReduction_268 happy_x_1+ = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn118+ (happy_var_1+ )}++happyReduce_269 = happyMonadReduce 1# 108# happyReduction_269+happyReduction_269 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut120 happy_x_1 of { happy_var_1 -> + ( checkEnabled KindSignatures >> return happy_var_1)}+ ) (\r -> happyReturn (happyIn119 r))++happyReduce_270 = happySpecReduce_1 109# happyReduction_270+happyReduction_270 happy_x_1+ = case happyOut121 happy_x_1 of { happy_var_1 -> + happyIn120+ (happy_var_1+ )}++happyReduce_271 = happySpecReduce_3 109# happyReduction_271+happyReduction_271 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut121 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> + case happyOut120 happy_x_3 of { happy_var_3 -> + happyIn120+ (KindFn (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_272 = happySpecReduce_1 110# happyReduction_272+happyReduction_272 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> + happyIn121+ (KindStar (nIS happy_var_1)+ )}++happyReduce_273 = happySpecReduce_1 110# happyReduction_273+happyReduction_273 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + happyIn121+ (KindBang (nIS happy_var_1)+ )}++happyReduce_274 = happySpecReduce_3 110# happyReduction_274+happyReduction_274 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut120 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn121+ (KindParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_275 = happySpecReduce_0 111# happyReduction_275+happyReduction_275 = happyIn122+ ((Nothing,[])+ )++happyReduce_276 = happySpecReduce_2 111# happyReduction_276+happyReduction_276 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> + case happyOut119 happy_x_2 of { happy_var_2 -> + happyIn122+ ((Just happy_var_2,[happy_var_1])+ )}}++happyReduce_277 = happyMonadReduce 4# 112# happyReduction_277+happyReduction_277 (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 { (Loc happy_var_1 KW_Where) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOut124 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> + ( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+ ) (\r -> happyReturn (happyIn123 r))++happyReduce_278 = happyMonadReduce 4# 112# happyReduction_278+happyReduction_278 (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 { (Loc happy_var_1 KW_Where) -> + case happyOut222 happy_x_2 of { happy_var_2 -> + case happyOut124 happy_x_3 of { happy_var_3 -> + case happyOut223 happy_x_4 of { happy_var_4 -> + ( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+ ) (\r -> happyReturn (happyIn123 r))++happyReduce_279 = happySpecReduce_0 112# happyReduction_279+happyReduction_279 = happyIn123+ ((Nothing,[],Nothing)+ )++happyReduce_280 = happyMonadReduce 3# 113# happyReduction_280+happyReduction_280 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + ( checkRevClsDecls (fst happy_var_2) >>= \cs -> return (cs, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+ ) (\r -> happyReturn (happyIn124 r))++happyReduce_281 = happySpecReduce_1 113# happyReduction_281+happyReduction_281 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn124+ (([],reverse happy_var_1)+ )}++happyReduce_282 = happySpecReduce_3 114# happyReduction_282+happyReduction_282 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut125 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + happyIn125+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_283 = happySpecReduce_1 114# happyReduction_283+happyReduction_283 happy_x_1+ = case happyOut126 happy_x_1 of { happy_var_1 -> + happyIn125+ (([happy_var_1],[])+ )}++happyReduce_284 = happySpecReduce_1 115# happyReduction_284+happyReduction_284 happy_x_1+ = case happyOut55 happy_x_1 of { happy_var_1 -> + happyIn126+ (ClsDecl (ann happy_var_1) happy_var_1+ )}++happyReduce_285 = happyMonadReduce 1# 115# happyReduction_285+happyReduction_285 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + ( checkEnabled TypeFamilies >> return happy_var_1)}+ ) (\r -> happyReturn (happyIn126 r))++happyReduce_286 = happyMonadReduce 3# 116# happyReduction_286+happyReduction_286 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> + case happyOut80 happy_x_2 of { happy_var_2 -> + case happyOut122 happy_x_3 of { happy_var_3 -> + ( do { dh <- checkSimpleType happy_var_2;+ return (ClsTyFam (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) dh (fst happy_var_3)) })}}}+ ) (\r -> happyReturn (happyIn127 r))++happyReduce_287 = happyReduce 4# 116# happyReduction_287+happyReduction_287 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> + case happyOut77 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> + case happyOut88 happy_x_4 of { happy_var_4 -> + happyIn127+ (ClsTyDef (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_288 = happyMonadReduce 3# 116# happyReduction_288+happyReduction_288 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> + case happyOut89 happy_x_2 of { happy_var_2 -> + case happyOut122 happy_x_3 of { happy_var_3 -> + ( do { (cs,dh) <- checkDataHeader happy_var_2;+ return (ClsDataFam (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) cs dh (fst happy_var_3)) })}}}+ ) (\r -> happyReturn (happyIn127 r))++happyReduce_289 = happyMonadReduce 4# 117# happyReduction_289+happyReduction_289 (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 { (Loc happy_var_1 KW_Where) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOut129 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> + ( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+ ) (\r -> happyReturn (happyIn128 r))++happyReduce_290 = happyMonadReduce 4# 117# happyReduction_290+happyReduction_290 (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 { (Loc happy_var_1 KW_Where) -> + case happyOut222 happy_x_2 of { happy_var_2 -> + case happyOut129 happy_x_3 of { happy_var_3 -> + case happyOut223 happy_x_4 of { happy_var_4 -> + ( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+ ) (\r -> happyReturn (happyIn128 r))++happyReduce_291 = happySpecReduce_0 117# happyReduction_291+happyReduction_291 = happyIn128+ ((Nothing, [], Nothing)+ )++happyReduce_292 = happyMonadReduce 3# 118# happyReduction_292+happyReduction_292 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut130 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + ( checkRevInstDecls (fst happy_var_2) >>= \is -> return (is, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+ ) (\r -> happyReturn (happyIn129 r))++happyReduce_293 = happySpecReduce_1 118# happyReduction_293+happyReduction_293 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn129+ (([],reverse happy_var_1)+ )}++happyReduce_294 = happySpecReduce_3 119# happyReduction_294+happyReduction_294 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut130 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut131 happy_x_3 of { happy_var_3 -> + happyIn130+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_295 = happySpecReduce_1 119# happyReduction_295+happyReduction_295 happy_x_1+ = case happyOut131 happy_x_1 of { happy_var_1 -> + happyIn130+ (([happy_var_1],[])+ )}++happyReduce_296 = happySpecReduce_1 120# happyReduction_296+happyReduction_296 happy_x_1+ = case happyOut133 happy_x_1 of { happy_var_1 -> + happyIn131+ (InsDecl (ann happy_var_1) happy_var_1+ )}++happyReduce_297 = happyMonadReduce 1# 120# happyReduction_297+happyReduction_297 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut132 happy_x_1 of { happy_var_1 -> + ( checkEnabled TypeFamilies >> return happy_var_1)}+ ) (\r -> happyReturn (happyIn131 r))++happyReduce_298 = happySpecReduce_1 120# happyReduction_298+happyReduction_298 happy_x_1+ = case happyOut58 happy_x_1 of { happy_var_1 -> + happyIn131+ (InsDecl (ann happy_var_1) happy_var_1+ )}++happyReduce_299 = happyMonadReduce 4# 121# happyReduction_299+happyReduction_299 (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 { (Loc happy_var_1 KW_Type) -> + case happyOut77 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> + case happyOut88 happy_x_4 of { happy_var_4 -> + ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns+ return (InsType (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn132 r))++happyReduce_300 = happyMonadReduce 4# 121# happyReduction_300+happyReduction_300 (happy_x_4 `HappyStk`+ 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 happyOut88 happy_x_2 of { happy_var_2 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + case happyOut116 happy_x_4 of { happy_var_4 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+ let {(ds,ss,minf) = happy_var_3};+ checkDataOrNew happy_var_1 ds;+ return (InsData (happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss ) happy_var_1 happy_var_2 (reverse ds) happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn132 r))++happyReduce_301 = happyMonadReduce 5# 121# happyReduction_301+happyReduction_301 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ 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 happyOut88 happy_x_2 of { happy_var_2 -> + case happyOut122 happy_x_3 of { happy_var_3 -> + case happyOut100 happy_x_4 of { happy_var_4 -> + case happyOut116 happy_x_5 of { happy_var_5 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+ let { (gs,ss,minf) = happy_var_4 } ;+ checkDataOrNewG happy_var_1 gs;+ return $ InsGData (ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)) happy_var_1 happy_var_2 (fst happy_var_3) (reverse gs) happy_var_5 })}}}}}+ ) (\r -> happyReturn (happyIn132 r))++happyReduce_302 = happyMonadReduce 4# 122# happyReduction_302+happyReduction_302 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_2 of { happy_var_2 -> + case happyOut136 happy_x_3 of { happy_var_3 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + ( checkValDef ((happy_var_1 <> happy_var_3 <+?> (fmap ann) (fst happy_var_4)) <** (snd happy_var_2 ++ snd happy_var_4)) happy_var_1 (fst happy_var_2) happy_var_3 (fst happy_var_4))}}}}+ ) (\r -> happyReturn (happyIn133 r))++happyReduce_303 = happyMonadReduce 4# 122# happyReduction_303+happyReduction_303 (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 { (Loc happy_var_1 Exclamation) -> + case happyOut150 happy_x_2 of { happy_var_2 -> + case happyOut136 happy_x_3 of { happy_var_3 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + ( do { checkEnabled BangPatterns ;+ let { l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] };+ p <- checkPattern (BangPat l happy_var_2);+ return $ PatBind (p <> happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** snd happy_var_4)+ p Nothing happy_var_3 (fst happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn133 r))++happyReduce_304 = happySpecReduce_2 123# happyReduction_304+happyReduction_304 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn134+ ((Just happy_var_2, [happy_var_1])+ )}}++happyReduce_305 = happySpecReduce_0 123# happyReduction_305+happyReduction_305 = happyIn134+ ((Nothing, [])+ )++happyReduce_306 = happyMonadReduce 2# 124# happyReduction_306+happyReduction_306 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> + case happyOut88 happy_x_2 of { happy_var_2 -> + ( checkEnabled ScopedTypeVariables >> return (Just happy_var_2, [happy_var_1]))}}+ ) (\r -> happyReturn (happyIn135 r))++happyReduce_307 = happySpecReduce_0 124# happyReduction_307+happyReduction_307 = happyIn135+ ((Nothing,[])+ )++happyReduce_308 = happySpecReduce_2 125# happyReduction_308+happyReduction_308 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + happyIn136+ (UnGuardedRhs (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_309 = happySpecReduce_1 125# happyReduction_309+happyReduction_309 happy_x_1+ = case happyOut137 happy_x_1 of { happy_var_1 -> + happyIn136+ (GuardedRhss (snd happy_var_1) (reverse $ fst happy_var_1)+ )}++happyReduce_310 = happySpecReduce_2 126# happyReduction_310+happyReduction_310 happy_x_2+ happy_x_1+ = case happyOut137 happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_2 of { happy_var_2 -> + happyIn137+ ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)+ )}}++happyReduce_311 = happySpecReduce_1 126# happyReduction_311+happyReduction_311 happy_x_1+ = case happyOut138 happy_x_1 of { happy_var_1 -> + happyIn137+ (([happy_var_1],ann happy_var_1)+ )}++happyReduce_312 = happyMonadReduce 4# 127# happyReduction_312+happyReduction_312 (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 { (Loc happy_var_1 Bar) -> + case happyOut173 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + ( do { checkPatternGuards (fst happy_var_2);+ return $ GuardedRhs (nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])) (reverse (fst happy_var_2)) happy_var_4 })}}}}+ ) (\r -> happyReturn (happyIn138 r))++happyReduce_313 = happyMonadReduce 1# 128# happyReduction_313+happyReduction_313 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> + ( checkExpr happy_var_1)}+ ) (\r -> happyReturn (happyIn139 r))++happyReduce_314 = happySpecReduce_3 129# happyReduction_314+happyReduction_314 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn140+ (ExpTypeSig (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_315 = happySpecReduce_1 129# happyReduction_315+happyReduction_315 happy_x_1+ = case happyOut141 happy_x_1 of { happy_var_1 -> + happyIn140+ (happy_var_1+ )}++happyReduce_316 = happySpecReduce_2 129# happyReduction_316+happyReduction_316 happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOut205 happy_x_2 of { happy_var_2 -> + happyIn140+ (PostOp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+ )}}++happyReduce_317 = happySpecReduce_3 129# happyReduction_317+happyReduction_317 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrowTail) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn140+ (LeftArrApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_318 = happySpecReduce_3 129# happyReduction_318+happyReduction_318 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrowTail) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn140+ (RightArrApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_319 = happySpecReduce_3 129# happyReduction_319+happyReduction_319 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftDblArrowTail) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn140+ (LeftArrHighApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_320 = happySpecReduce_3 129# happyReduction_320+happyReduction_320 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightDblArrowTail) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn140+ (RightArrHighApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_321 = happySpecReduce_1 130# happyReduction_321+happyReduction_321 happy_x_1+ = case happyOut142 happy_x_1 of { happy_var_1 -> + happyIn141+ (happy_var_1+ )}++happyReduce_322 = happySpecReduce_1 130# happyReduction_322+happyReduction_322 happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + happyIn141+ (happy_var_1+ )}++happyReduce_323 = happySpecReduce_3 131# happyReduction_323+happyReduction_323 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOut205 happy_x_2 of { happy_var_2 -> + case happyOut144 happy_x_3 of { happy_var_3 -> + happyIn142+ (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+ )}}}++happyReduce_324 = happySpecReduce_1 131# happyReduction_324+happyReduction_324 happy_x_1+ = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn142+ (happy_var_1+ )}++happyReduce_325 = happySpecReduce_3 132# happyReduction_325+happyReduction_325 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOut205 happy_x_2 of { happy_var_2 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + happyIn143+ (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+ )}}}++happyReduce_326 = happySpecReduce_1 132# happyReduction_326+happyReduction_326 happy_x_1+ = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn143+ (happy_var_1+ )}++happyReduce_327 = happyReduce 4# 133# 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 { (Loc happy_var_1 Backslash) -> + case happyOut148 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + happyIn144+ (Lambda (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (reverse happy_var_2) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_328 = happyReduce 4# 133# 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 { (Loc happy_var_1 KW_Let) -> + case happyOut61 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_In) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + happyIn144+ (Let (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_329 = happyReduce 6# 133# happyReduction_329+happyReduction_329 (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 { (Loc happy_var_1 KW_If) -> + case happyOut140 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Then) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Else) -> + case happyOut140 happy_x_6 of { happy_var_6 -> + happyIn144+ (If (nIS happy_var_1 <++> ann happy_var_6 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4 happy_var_6+ ) `HappyStk` happyRest}}}}}}++happyReduce_330 = happyReduce 4# 133# 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 { (Loc happy_var_1 KW_Proc) -> + case happyOut149 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + happyIn144+ (Proc (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_331 = happySpecReduce_1 133# happyReduction_331+happyReduction_331 happy_x_1+ = case happyOut146 happy_x_1 of { happy_var_1 -> + happyIn144+ (happy_var_1+ )}++happyReduce_332 = happyReduce 4# 134# happyReduction_332+happyReduction_332 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Case) -> + case happyOut140 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Of) -> + case happyOut175 happy_x_4 of { happy_var_4 -> + happyIn145+ (let (als, inf, ss) = happy_var_4 in Case (nIS happy_var_1 <++> inf <** (happy_var_1:happy_var_3:ss)) happy_var_2 als+ ) `HappyStk` happyRest}}}}++happyReduce_333 = happySpecReduce_2 134# happyReduction_333+happyReduction_333 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> + case happyOut147 happy_x_2 of { happy_var_2 -> + happyIn145+ (NegApp (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_334 = happySpecReduce_2 134# happyReduction_334+happyReduction_334 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> + case happyOut183 happy_x_2 of { happy_var_2 -> + happyIn145+ (let (sts, inf, ss) = happy_var_2 in Do (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts+ )}}++happyReduce_335 = happySpecReduce_2 134# happyReduction_335+happyReduction_335 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> + case happyOut183 happy_x_2 of { happy_var_2 -> + happyIn145+ (let (sts, inf, ss) = happy_var_2 in MDo (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts+ )}}++happyReduce_336 = happySpecReduce_1 134# happyReduction_336+happyReduction_336 happy_x_1+ = case happyOut147 happy_x_1 of { happy_var_1 -> + happyIn145+ (happy_var_1+ )}++happyReduce_337 = happyReduce 4# 135# happyReduction_337+happyReduction_337 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 CORE) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + happyIn146+ (let Loc l (StringTok (s,_)) = happy_var_2 in CorePragma (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_338 = happyReduce 4# 135# happyReduction_338+happyReduction_338 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 SCC) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> + case happyOut140 happy_x_4 of { happy_var_4 -> + happyIn146+ (let Loc l (StringTok (s,_)) = happy_var_2 in SCCPragma (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_339 = happyReduce 11# 135# happyReduction_339+happyReduction_339 (happy_x_11 `HappyStk`+ happy_x_10 `HappyStk`+ happy_x_9 `HappyStk`+ happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 GENERATED) -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 Colon) -> + case happyOutTok happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { (Loc happy_var_6 Minus) -> + case happyOutTok happy_x_7 of { happy_var_7 -> + case happyOutTok happy_x_8 of { (Loc happy_var_8 Colon) -> + case happyOutTok happy_x_9 of { happy_var_9 -> + case happyOutTok happy_x_10 of { (Loc happy_var_10 PragmaEnd) -> + case happyOut140 happy_x_11 of { happy_var_11 -> + happyIn146+ (let { Loc l0 (StringTok (s,_)) = happy_var_2;+ Loc l1 (IntTok (i1,_)) = happy_var_3;+ Loc l2 (IntTok (i2,_)) = happy_var_5;+ Loc l3 (IntTok (i3,_)) = happy_var_7;+ Loc l4 (IntTok (i4,_)) = happy_var_9}+ in GenPragma (nIS happy_var_1 <++> ann happy_var_11 <** [happy_var_1,l0,l1,happy_var_4,l2,happy_var_6,l3,happy_var_8,l4,happy_var_10])+ s (fromInteger i1, fromInteger i2)+ (fromInteger i3, fromInteger i4) happy_var_11+ ) `HappyStk` happyRest}}}}}}}}}}}++happyReduce_340 = happySpecReduce_2 136# happyReduction_340+happyReduction_340 happy_x_2+ happy_x_1+ = case happyOut147 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_2 of { happy_var_2 -> + happyIn147+ (App (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+ )}}++happyReduce_341 = happySpecReduce_1 136# happyReduction_341+happyReduction_341 happy_x_1+ = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn147+ (happy_var_1+ )}++happyReduce_342 = happySpecReduce_2 137# happyReduction_342+happyReduction_342 happy_x_2+ happy_x_1+ = case happyOut148 happy_x_1 of { happy_var_1 -> + case happyOut149 happy_x_2 of { happy_var_2 -> + happyIn148+ (happy_var_2 : happy_var_1+ )}}++happyReduce_343 = happySpecReduce_1 137# happyReduction_343+happyReduction_343 happy_x_1+ = case happyOut149 happy_x_1 of { happy_var_1 -> + happyIn148+ ([happy_var_1]+ )}++happyReduce_344 = happyMonadReduce 1# 138# happyReduction_344+happyReduction_344 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut150 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)}+ ) (\r -> happyReturn (happyIn149 r))++happyReduce_345 = happyMonadReduce 2# 138# happyReduction_345+happyReduction_345 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + case happyOut150 happy_x_2 of { happy_var_2 -> + ( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}+ ) (\r -> happyReturn (happyIn149 r))++happyReduce_346 = happyMonadReduce 3# 139# happyReduction_346+happyReduction_346 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut195 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 At) -> + case happyOut150 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1;+ return (AsPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}+ ) (\r -> happyReturn (happyIn150 r))++happyReduce_347 = happyMonadReduce 3# 139# happyReduction_347+happyReduction_347 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut195 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RPCAt) -> + case happyOut150 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1;+ return (CAsRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}+ ) (\r -> happyReturn (happyIn150 r))++happyReduce_348 = happySpecReduce_2 139# happyReduction_348+happyReduction_348 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Tilde) -> + case happyOut150 happy_x_2 of { happy_var_2 -> + happyIn150+ (IrrPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_349 = happySpecReduce_1 139# happyReduction_349+happyReduction_349 happy_x_1+ = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn150+ (happy_var_1+ )}++happyReduce_350 = happyMonadReduce 3# 140# happyReduction_350+happyReduction_350 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + ( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]))) $ mkRecConstrOrUpdate happy_var_1 [])}}}+ ) (\r -> happyReturn (happyIn151 r))++happyReduce_351 = happyMonadReduce 4# 140# happyReduction_351+happyReduction_351 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> + case happyOut187 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> + ( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4]))))+ $ mkRecConstrOrUpdate happy_var_1 (reverse (fst happy_var_3)))}}}}+ ) (\r -> happyReturn (happyIn151 r))++happyReduce_352 = happyReduce 4# 140# happyReduction_352+happyReduction_352 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut195 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurlyBar) -> + case happyOut79 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurlyBar) -> + happyIn151+ (ExplTypeArg (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3+ ) `HappyStk` happyRest}}}}++happyReduce_353 = happySpecReduce_1 140# happyReduction_353+happyReduction_353 happy_x_1+ = case happyOut152 happy_x_1 of { happy_var_1 -> + happyIn151+ (happy_var_1+ )}++happyReduce_354 = happySpecReduce_1 141# happyReduction_354+happyReduction_354 happy_x_1+ = case happyOut196 happy_x_1 of { happy_var_1 -> + happyIn152+ (IPVar (ann happy_var_1) happy_var_1+ )}++happyReduce_355 = happySpecReduce_1 141# happyReduction_355+happyReduction_355 happy_x_1+ = case happyOut195 happy_x_1 of { happy_var_1 -> + happyIn152+ (Var (ann happy_var_1) happy_var_1+ )}++happyReduce_356 = happySpecReduce_1 141# happyReduction_356+happyReduction_356 happy_x_1+ = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn152+ (happy_var_1+ )}++happyReduce_357 = happySpecReduce_1 141# happyReduction_357+happyReduction_357 happy_x_1+ = case happyOut221 happy_x_1 of { happy_var_1 -> + happyIn152+ (Lit (ann happy_var_1) happy_var_1+ )}++happyReduce_358 = happySpecReduce_3 141# happyReduction_358+happyReduction_358 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn152+ (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_359 = happySpecReduce_3 141# happyReduction_359+happyReduction_359 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + happyIn152+ (TupleSection (happy_var_1 <^^> head (snd happy_var_3) <** happy_var_1:reverse (snd happy_var_3)) (Just happy_var_2 : fst happy_var_3)+ )}}}++happyReduce_360 = happyReduce 4# 141# happyReduction_360+happyReduction_360 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOut154 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> + happyIn152+ (TupleSection (happy_var_1 <^^> happy_var_4 <** happy_var_1:reverse (happy_var_4:happy_var_2))+ (replicate (length happy_var_2) Nothing ++ [Just happy_var_3])+ ) `HappyStk` happyRest}}}}++happyReduce_361 = happyReduce 4# 141# happyReduction_361+happyReduction_361 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOut154 happy_x_3 of { happy_var_3 -> + case happyOut155 happy_x_4 of { happy_var_4 -> + happyIn152+ (TupleSection (happy_var_1 <^^> head (snd happy_var_4) <** happy_var_1:reverse (snd happy_var_4 ++ happy_var_2))+ (replicate (length happy_var_2) Nothing ++ Just happy_var_3 : fst happy_var_4)+ ) `HappyStk` happyRest}}}}++happyReduce_362 = happySpecReduce_3 141# happyReduction_362+happyReduction_362 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOut167 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> + happyIn152+ (amap (\l -> l <** [happy_var_3]) $ happy_var_2 (happy_var_1 <^^> happy_var_3 <** [happy_var_1])+ )}}}++happyReduce_363 = happySpecReduce_1 141# happyReduction_363+happyReduction_363 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleUnderscore) -> + happyIn152+ (FreeSectSlot (nIS happy_var_1)+ )}++happyReduce_364 = happySpecReduce_1 141# happyReduction_364+happyReduction_364 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Underscore) -> + happyIn152+ (WildCard (nIS happy_var_1)+ )}++happyReduce_365 = happyMonadReduce 3# 141# happyReduction_365+happyReduction_365 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut157 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + ( checkEnabled RegularPatterns >> return (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2))}}}+ ) (\r -> happyReturn (happyIn152 r))++happyReduce_366 = happySpecReduce_3 141# happyReduction_366+happyReduction_366 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 RPGuardOpen) -> + case happyOut156 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RPGuardClose) -> + happyIn152+ (SeqRP (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (snd happy_var_2) ++ [happy_var_3])) $ reverse (fst happy_var_2)+ )}}}++happyReduce_367 = happyReduce 5# 141# happyReduction_367+happyReduction_367 (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 { (Loc happy_var_1 RPGuardOpen) -> + case happyOut140 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 Bar) -> + case happyOut173 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 RPGuardClose) -> + happyIn152+ (GuardRP (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3 : snd happy_var_4 ++ [happy_var_5])) happy_var_2 $ (reverse $ fst happy_var_4)+ ) `HappyStk` happyRest}}}}}++happyReduce_368 = happySpecReduce_1 141# happyReduction_368+happyReduction_368 happy_x_1+ = case happyOut158 happy_x_1 of { happy_var_1 -> + happyIn152+ (happy_var_1+ )}++happyReduce_369 = happySpecReduce_1 141# happyReduction_369+happyReduction_369 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn152+ (let Loc l (THIdEscape s) = happy_var_1 in SpliceExp (nIS l) $ IdSplice (nIS l) s+ )}++happyReduce_370 = happySpecReduce_3 141# happyReduction_370+happyReduction_370 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THParenEscape) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn152+ (SpliceExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ParenSplice (ann happy_var_2) happy_var_2+ )}}}++happyReduce_371 = happySpecReduce_3 141# happyReduction_371+happyReduction_371 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THExpQuote) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> + happyIn152+ (BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ExpBracket (ann happy_var_2) happy_var_2+ )}}}++happyReduce_372 = happyMonadReduce 3# 141# happyReduction_372+happyReduction_372 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 THPatQuote) -> + case happyOut141 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> + ( do { p <- checkPattern happy_var_2;+ return $ BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ PatBracket (ann p) p })}}}+ ) (\r -> happyReturn (happyIn152 r))++happyReduce_373 = happySpecReduce_3 141# happyReduction_373+happyReduction_373 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THTypQuote) -> + case happyOut88 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> + happyIn152+ (let l = happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3] in BracketExp l $ TypeBracket l happy_var_2+ )}}}++happyReduce_374 = happyReduce 5# 141# happyReduction_374+happyReduction_374 (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 { (Loc happy_var_1 THDecQuote) -> + case happyOut48 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 THCloseQuote) -> + happyIn152+ (let l = happy_var_1 <^^> happy_var_5 <** (happy_var_1:snd happy_var_3 ++ [happy_var_5]) in BracketExp l $ DeclBracket l (fst happy_var_3)+ ) `HappyStk` happyRest}}}++happyReduce_375 = happySpecReduce_2 141# happyReduction_375+happyReduction_375 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> + case happyOut195 happy_x_2 of { happy_var_2 -> + happyIn152+ (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_376 = happySpecReduce_2 141# happyReduction_376+happyReduction_376 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> + case happyOut198 happy_x_2 of { happy_var_2 -> + happyIn152+ (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_377 = happySpecReduce_2 141# happyReduction_377+happyReduction_377 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> + case happyOut227 happy_x_2 of { happy_var_2 -> + happyIn152+ (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) (UnQual (ann happy_var_2) happy_var_2)+ )}}++happyReduce_378 = happySpecReduce_2 141# happyReduction_378+happyReduction_378 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> + case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn152+ (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_379 = happySpecReduce_1 141# happyReduction_379+happyReduction_379 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn152+ (let Loc l (THQuasiQuote (n,q)) = happy_var_1 in QuasiQuote (nIS l) n q+ )}++happyReduce_380 = happySpecReduce_3 141# happyReduction_380+happyReduction_380 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 FSContextOpen) -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 FSContextClose) -> + happyIn152+ (FSContext (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_381 = happySpecReduce_2 142# happyReduction_381+happyReduction_381 happy_x_2+ happy_x_1+ = case happyOut153 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + happyIn153+ (happy_var_2 : happy_var_1+ )}}++happyReduce_382 = happySpecReduce_1 142# happyReduction_382+happyReduction_382 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> + happyIn153+ ([happy_var_1]+ )}++happyReduce_383 = happySpecReduce_1 143# happyReduction_383+happyReduction_383 happy_x_1+ = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn154+ (happy_var_1+ )}++happyReduce_384 = happySpecReduce_2 143# happyReduction_384+happyReduction_384 happy_x_2+ happy_x_1+ = case happyOut206 happy_x_1 of { happy_var_1 -> + case happyOut141 happy_x_2 of { happy_var_2 -> + happyIn154+ (PreOp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+ )}}++happyReduce_385 = happyMonadReduce 3# 143# happyReduction_385+happyReduction_385 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + ( do {checkEnabled ViewPatterns;+ return $ ViewPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3})}}}+ ) (\r -> happyReturn (happyIn154 r))++happyReduce_386 = happySpecReduce_3 144# happyReduction_386+happyReduction_386 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut153 happy_x_1 of { happy_var_1 -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + happyIn155+ (let (mes, ss) = happy_var_3 in (replicate (length happy_var_1 - 1) Nothing ++ Just happy_var_2 : mes, ss ++ happy_var_1)+ )}}}++happyReduce_387 = happySpecReduce_3 144# happyReduction_387+happyReduction_387 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut153 happy_x_1 of { happy_var_1 -> + case happyOut154 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn155+ ((replicate (length happy_var_1 - 1) Nothing ++ [Just happy_var_2], happy_var_3 : happy_var_1)+ )}}}++happyReduce_388 = happySpecReduce_2 144# happyReduction_388+happyReduction_388 happy_x_2+ happy_x_1+ = case happyOut153 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> + happyIn155+ ((replicate (length happy_var_1) Nothing, happy_var_2 : happy_var_1)+ )}}++happyReduce_389 = happySpecReduce_3 145# happyReduction_389+happyReduction_389 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut156 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn156+ ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+ )}}}++happyReduce_390 = happySpecReduce_1 145# happyReduction_390+happyReduction_390 happy_x_1+ = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn156+ (([happy_var_1],[])+ )}++happyReduce_391 = happySpecReduce_3 146# happyReduction_391+happyReduction_391 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut140 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> + case happyOut157 happy_x_3 of { happy_var_3 -> + happyIn157+ (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_392 = happySpecReduce_3 146# happyReduction_392+happyReduction_392 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut140 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn157+ (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_393 = happyMonadReduce 9# 147# happyReduction_393+happyReduction_393 (happy_x_9 `HappyStk`+ happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> + case happyOut161 happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOut166 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> + case happyOut159 happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { (Loc happy_var_7 XCloseTagOpen) -> + case happyOut161 happy_x_8 of { happy_var_8 -> + case happyOutTok happy_x_9 of { (Loc happy_var_9 XStdTagClose) -> + ( do { n <- checkEqNames happy_var_2 happy_var_8;+ let { cn = reverse happy_var_6;+ as = reverse happy_var_3;+ l = happy_var_1 <^^> happy_var_9 <** [happy_var_1,happy_var_5,happy_var_7,srcInfoSpan (ann happy_var_8),happy_var_9] };+ return $ XTag l n as happy_var_4 cn })}}}}}}}}}+ ) (\r -> happyReturn (happyIn158 r))++happyReduce_394 = happyReduce 5# 147# 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 happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> + case happyOut161 happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOut166 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> + happyIn158+ (XETag (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4+ ) `HappyStk` happyRest}}}}}++happyReduce_395 = happySpecReduce_3 147# happyReduction_395+happyReduction_395 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 XCodeTagOpen) -> + case happyOut140 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 XCodeTagClose) -> + happyIn158+ (XExpTag (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+ )}}}++happyReduce_396 = happyReduce 4# 147# happyReduction_396+happyReduction_396 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 XChildTagOpen) -> + case happyOut159 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 XCloseTagOpen) -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 XCodeTagClose) -> + happyIn158+ (XChildTag (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_3,happy_var_4]) (reverse happy_var_2)+ ) `HappyStk` happyRest}}}}++happyReduce_397 = happySpecReduce_2 148# happyReduction_397+happyReduction_397 happy_x_2+ happy_x_1+ = case happyOut159 happy_x_1 of { happy_var_1 -> + case happyOut160 happy_x_2 of { happy_var_2 -> + happyIn159+ (happy_var_2 : happy_var_1+ )}}++happyReduce_398 = happySpecReduce_0 148# happyReduction_398+happyReduction_398 = happyIn159+ ([]+ )++happyReduce_399 = happySpecReduce_1 149# happyReduction_399+happyReduction_399 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn160+ (let Loc l (XPCDATA pcd) = happy_var_1 in XPcdata (nIS l) pcd+ )}++happyReduce_400 = happySpecReduce_3 149# happyReduction_400+happyReduction_400 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 XRPatOpen) -> + case happyOut156 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 XRPatClose) -> + happyIn160+ (XRPats (happy_var_1 <^^> happy_var_3 <** (snd happy_var_2 ++ [happy_var_1,happy_var_3])) $ reverse (fst happy_var_2)+ )}}}++happyReduce_401 = happySpecReduce_1 149# happyReduction_401+happyReduction_401 happy_x_1+ = case happyOut158 happy_x_1 of { happy_var_1 -> + happyIn160+ (happy_var_1+ )}++happyReduce_402 = happySpecReduce_3 150# happyReduction_402+happyReduction_402 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut162 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Colon) -> + case happyOut162 happy_x_3 of { happy_var_3 -> + happyIn161+ (let {Loc l1 s1 = happy_var_1; Loc l2 s2 = happy_var_3}+ in XDomName (nIS l1 <++> nIS l2 <** [l1,happy_var_2,l2]) s1 s2+ )}}}++happyReduce_403 = happySpecReduce_1 150# happyReduction_403+happyReduction_403 happy_x_1+ = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn161+ (let Loc l str = happy_var_1 in XName (nIS l) str+ )}++happyReduce_404 = happySpecReduce_1 151# happyReduction_404+happyReduction_404 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn162+ (let Loc l (VarId s) = happy_var_1 in Loc l s+ )}++happyReduce_405 = happySpecReduce_1 151# happyReduction_405+happyReduction_405 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn162+ (let Loc l (ConId s) = happy_var_1 in Loc l s+ )}++happyReduce_406 = happySpecReduce_1 151# happyReduction_406+happyReduction_406 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn162+ (let Loc l (DVarId s) = happy_var_1 in Loc l $ mkDVar s+ )}++happyReduce_407 = happySpecReduce_1 151# happyReduction_407+happyReduction_407 happy_x_1+ = case happyOut163 happy_x_1 of { happy_var_1 -> + happyIn162+ (happy_var_1+ )}++happyReduce_408 = happySpecReduce_1 152# happyReduction_408+happyReduction_408 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> + happyIn163+ (Loc happy_var_1 "type"+ )}++happyReduce_409 = happySpecReduce_1 152# happyReduction_409+happyReduction_409 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Class) -> + happyIn163+ (Loc happy_var_1 "class"+ )}++happyReduce_410 = happySpecReduce_1 152# happyReduction_410+happyReduction_410 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> + happyIn163+ (Loc happy_var_1 "data"+ )}++happyReduce_411 = happySpecReduce_1 152# happyReduction_411+happyReduction_411 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> + happyIn163+ (Loc happy_var_1 "foreign"+ )}++happyReduce_412 = happySpecReduce_1 152# happyReduction_412+happyReduction_412 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> + happyIn163+ (Loc happy_var_1 "export"+ )}++happyReduce_413 = happySpecReduce_1 152# happyReduction_413+happyReduction_413 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> + happyIn163+ (Loc happy_var_1 "safe"+ )}++happyReduce_414 = happySpecReduce_1 152# happyReduction_414+happyReduction_414 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> + happyIn163+ (Loc happy_var_1 "unsafe"+ )}++happyReduce_415 = happySpecReduce_1 152# happyReduction_415+happyReduction_415 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> + happyIn163+ (Loc happy_var_1 "threadsafe"+ )}++happyReduce_416 = happySpecReduce_1 152# happyReduction_416+happyReduction_416 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> + happyIn163+ (Loc happy_var_1 "stdcall"+ )}++happyReduce_417 = happySpecReduce_1 152# happyReduction_417+happyReduction_417 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> + happyIn163+ (Loc happy_var_1 "ccall"+ )}++happyReduce_418 = happySpecReduce_1 152# happyReduction_418+happyReduction_418 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> + happyIn163+ (Loc happy_var_1 "as"+ )}++happyReduce_419 = happySpecReduce_1 152# happyReduction_419+happyReduction_419 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_By) -> + happyIn163+ (Loc happy_var_1 "by"+ )}++happyReduce_420 = happySpecReduce_1 152# happyReduction_420+happyReduction_420 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Case) -> + happyIn163+ (Loc happy_var_1 "case"+ )}++happyReduce_421 = happySpecReduce_1 152# happyReduction_421+happyReduction_421 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> + happyIn163+ (Loc happy_var_1 "default"+ )}++happyReduce_422 = happySpecReduce_1 152# happyReduction_422+happyReduction_422 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> + happyIn163+ (Loc happy_var_1 "deriving"+ )}++happyReduce_423 = happySpecReduce_1 152# happyReduction_423+happyReduction_423 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> + happyIn163+ (Loc happy_var_1 "do"+ )}++happyReduce_424 = happySpecReduce_1 152# happyReduction_424+happyReduction_424 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Else) -> + happyIn163+ (Loc happy_var_1 "else"+ )}++happyReduce_425 = happySpecReduce_1 152# happyReduction_425+happyReduction_425 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Family) -> + happyIn163+ (Loc happy_var_1 "family"+ )}++happyReduce_426 = happySpecReduce_1 152# happyReduction_426+happyReduction_426 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> + happyIn163+ (Loc happy_var_1 "forall"+ )}++happyReduce_427 = happySpecReduce_1 152# happyReduction_427+happyReduction_427 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Group) -> + happyIn163+ (Loc happy_var_1 "group"+ )}++happyReduce_428 = happySpecReduce_1 152# happyReduction_428+happyReduction_428 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> + happyIn163+ (Loc happy_var_1 "hiding"+ )}++happyReduce_429 = happySpecReduce_1 152# happyReduction_429+happyReduction_429 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_If) -> + happyIn163+ (Loc happy_var_1 "if"+ )}++happyReduce_430 = happySpecReduce_1 152# happyReduction_430+happyReduction_430 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Import) -> + happyIn163+ (Loc happy_var_1 "import"+ )}++happyReduce_431 = happySpecReduce_1 152# happyReduction_431+happyReduction_431 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_In) -> + happyIn163+ (Loc happy_var_1 "in"+ )}++happyReduce_432 = happySpecReduce_1 152# happyReduction_432+happyReduction_432 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> + happyIn163+ (Loc happy_var_1 "infix"+ )}++happyReduce_433 = happySpecReduce_1 152# happyReduction_433+happyReduction_433 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> + happyIn163+ (Loc happy_var_1 "infixl"+ )}++happyReduce_434 = happySpecReduce_1 152# happyReduction_434+happyReduction_434 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> + happyIn163+ (Loc happy_var_1 "infixr"+ )}++happyReduce_435 = happySpecReduce_1 152# happyReduction_435+happyReduction_435 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> + happyIn163+ (Loc happy_var_1 "instance"+ )}++happyReduce_436 = happySpecReduce_1 152# happyReduction_436+happyReduction_436 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> + happyIn163+ (Loc happy_var_1 "let"+ )}++happyReduce_437 = happySpecReduce_1 152# happyReduction_437+happyReduction_437 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> + happyIn163+ (Loc happy_var_1 "mdo"+ )}++happyReduce_438 = happySpecReduce_1 152# happyReduction_438+happyReduction_438 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> + happyIn163+ (Loc happy_var_1 "module"+ )}++happyReduce_439 = happySpecReduce_1 152# happyReduction_439+happyReduction_439 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> + happyIn163+ (Loc happy_var_1 "newtype"+ )}++happyReduce_440 = happySpecReduce_1 152# happyReduction_440+happyReduction_440 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Of) -> + happyIn163+ (Loc happy_var_1 "of"+ )}++happyReduce_441 = happySpecReduce_1 152# happyReduction_441+happyReduction_441 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Proc) -> + happyIn163+ (Loc happy_var_1 "proc"+ )}++happyReduce_442 = happySpecReduce_1 152# happyReduction_442+happyReduction_442 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> + happyIn163+ (Loc happy_var_1 "rec"+ )}++happyReduce_443 = happySpecReduce_1 152# happyReduction_443+happyReduction_443 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> + happyIn163+ (Loc happy_var_1 "then"+ )}++happyReduce_444 = happySpecReduce_1 152# happyReduction_444+happyReduction_444 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Using) -> + happyIn163+ (Loc happy_var_1 "using"+ )}++happyReduce_445 = happySpecReduce_1 152# happyReduction_445+happyReduction_445 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> + happyIn163+ (Loc happy_var_1 "where"+ )}++happyReduce_446 = happySpecReduce_1 152# happyReduction_446+happyReduction_446 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> + happyIn163+ (Loc happy_var_1 "qualified"+ )}++happyReduce_447 = happySpecReduce_2 153# happyReduction_447+happyReduction_447 happy_x_2+ happy_x_1+ = case happyOut164 happy_x_1 of { happy_var_1 -> + case happyOut165 happy_x_2 of { happy_var_2 -> + happyIn164+ (happy_var_2 : happy_var_1+ )}}++happyReduce_448 = happySpecReduce_0 153# happyReduction_448+happyReduction_448 = happyIn164+ ([]+ )++happyReduce_449 = happySpecReduce_3 154# happyReduction_449+happyReduction_449 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut161 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> + case happyOut150 happy_x_3 of { happy_var_3 -> + happyIn165+ (XAttr (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_450 = happySpecReduce_1 155# happyReduction_450+happyReduction_450 happy_x_1+ = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn166+ (Just happy_var_1+ )}++happyReduce_451 = happySpecReduce_0 155# happyReduction_451+happyReduction_451 = happyIn166+ (Nothing+ )++happyReduce_452 = happySpecReduce_1 156# happyReduction_452+happyReduction_452 happy_x_1+ = case happyOut154 happy_x_1 of { happy_var_1 -> + happyIn167+ (\l -> List l [happy_var_1]+ )}++happyReduce_453 = happySpecReduce_1 156# happyReduction_453+happyReduction_453 happy_x_1+ = case happyOut168 happy_x_1 of { happy_var_1 -> + happyIn167+ (\l -> let (ps,ss) = happy_var_1 in List (l <** reverse ss) (reverse ps)+ )}++happyReduce_454 = happySpecReduce_2 156# happyReduction_454+happyReduction_454 happy_x_2+ happy_x_1+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> + happyIn167+ (\l -> EnumFrom (l <** [happy_var_2]) happy_var_1+ )}}++happyReduce_455 = happyReduce 4# 156# happyReduction_455+happyReduction_455 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> + happyIn167+ (\l -> EnumFromThen (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3+ ) `HappyStk` happyRest}}}}++happyReduce_456 = happySpecReduce_3 156# happyReduction_456+happyReduction_456 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn167+ (\l -> EnumFromTo (l <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_457 = happyReduce 5# 156# happyReduction_457+happyReduction_457 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> + case happyOut140 happy_x_5 of { happy_var_5 -> + happyIn167+ (\l -> EnumFromThenTo (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3 happy_var_5+ ) `HappyStk` happyRest}}}}}++happyReduce_458 = happySpecReduce_3 156# happyReduction_458+happyReduction_458 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> + case happyOut169 happy_x_3 of { happy_var_3 -> + happyIn167+ (\l -> let (stss, ss) = happy_var_3 in ParComp (l <** (happy_var_2:ss)) happy_var_1 (reverse stss)+ )}}}++happyReduce_459 = happySpecReduce_3 157# happyReduction_459+happyReduction_459 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut168 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut154 happy_x_3 of { happy_var_3 -> + happyIn168+ (let (es, ss) = happy_var_1 in (happy_var_3 : es, happy_var_2 : ss)+ )}}}++happyReduce_460 = happySpecReduce_3 157# happyReduction_460+happyReduction_460 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut154 happy_x_3 of { happy_var_3 -> + happyIn168+ (([happy_var_3,happy_var_1], [happy_var_2])+ )}}}++happyReduce_461 = happySpecReduce_3 158# happyReduction_461+happyReduction_461 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut169 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> + case happyOut170 happy_x_3 of { happy_var_3 -> + happyIn169+ (let { (stss, ss1) = happy_var_1;+ (sts, ss2) = happy_var_3 }+ in (reverse sts : stss, ss1 ++ [happy_var_2] ++ reverse ss2)+ )}}}++happyReduce_462 = happySpecReduce_1 158# happyReduction_462+happyReduction_462 happy_x_1+ = case happyOut170 happy_x_1 of { happy_var_1 -> + happyIn169+ (let (sts, ss) = happy_var_1 in ([reverse sts], reverse ss)+ )}++happyReduce_463 = happySpecReduce_3 159# happyReduction_463+happyReduction_463 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut170 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut171 happy_x_3 of { happy_var_3 -> + happyIn170+ (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)+ )}}}++happyReduce_464 = happySpecReduce_1 159# happyReduction_464+happyReduction_464 happy_x_1+ = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn170+ (([happy_var_1],[])+ )}++happyReduce_465 = happySpecReduce_1 160# happyReduction_465+happyReduction_465 happy_x_1+ = case happyOut172 happy_x_1 of { happy_var_1 -> + happyIn171+ (happy_var_1+ )}++happyReduce_466 = happySpecReduce_1 160# happyReduction_466+happyReduction_466 happy_x_1+ = case happyOut174 happy_x_1 of { happy_var_1 -> + happyIn171+ (QualStmt (ann happy_var_1) happy_var_1+ )}++happyReduce_467 = happySpecReduce_2 161# happyReduction_467+happyReduction_467 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + happyIn172+ (ThenTrans (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_468 = happyReduce 4# 161# happyReduction_468+happyReduction_468 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + happyIn172+ (ThenBy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_469 = happyReduce 4# 161# happyReduction_469+happyReduction_469 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + happyIn172+ (GroupBy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_470 = happyReduce 4# 161# 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 { (Loc happy_var_1 KW_Then) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Using) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + happyIn172+ (GroupUsing (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+ ) `HappyStk` happyRest}}}}++happyReduce_471 = happyReduce 6# 161# happyReduction_471+happyReduction_471 (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 { (Loc happy_var_1 KW_Then) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Using) -> + case happyOut139 happy_x_6 of { happy_var_6 -> + happyIn172+ (GroupByUsing (nIS happy_var_1 <++> ann happy_var_6 <** [happy_var_1,happy_var_2,happy_var_3,happy_var_5]) happy_var_4 happy_var_6+ ) `HappyStk` happyRest}}}}}}++happyReduce_472 = happySpecReduce_3 162# happyReduction_472+happyReduction_472 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut173 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut174 happy_x_3 of { happy_var_3 -> + happyIn173+ (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)+ )}}}++happyReduce_473 = happySpecReduce_1 162# happyReduction_473+happyReduction_473 happy_x_1+ = case happyOut174 happy_x_1 of { happy_var_1 -> + happyIn173+ (([happy_var_1],[])+ )}++happyReduce_474 = happySpecReduce_3 163# happyReduction_474+happyReduction_474 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut182 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> + case happyOut139 happy_x_3 of { happy_var_3 -> + happyIn174+ (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_475 = happySpecReduce_1 163# happyReduction_475+happyReduction_475 happy_x_1+ = case happyOut139 happy_x_1 of { happy_var_1 -> + happyIn174+ (Qualifier (ann happy_var_1) happy_var_1+ )}++happyReduce_476 = happySpecReduce_2 163# happyReduction_476+happyReduction_476 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn174+ (LetStmt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_477 = happySpecReduce_3 164# happyReduction_477+happyReduction_477 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> + case happyOut176 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + happyIn175+ ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+ )}}}++happyReduce_478 = happySpecReduce_3 164# happyReduction_478+happyReduction_478 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut176 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn175+ ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+ )}}}++happyReduce_479 = happySpecReduce_3 165# happyReduction_479+happyReduction_479 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut177 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn176+ ((reverse $ fst happy_var_2, happy_var_1 ++ snd happy_var_2 ++ happy_var_3)+ )}}}++happyReduce_480 = happySpecReduce_3 166# happyReduction_480+happyReduction_480 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut177 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut178 happy_x_3 of { happy_var_3 -> + happyIn177+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ happy_var_2)+ )}}}++happyReduce_481 = happySpecReduce_1 166# happyReduction_481+happyReduction_481 happy_x_1+ = case happyOut178 happy_x_1 of { happy_var_1 -> + happyIn177+ (([happy_var_1],[])+ )}++happyReduce_482 = happySpecReduce_3 167# happyReduction_482+happyReduction_482 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut182 happy_x_1 of { happy_var_1 -> + case happyOut179 happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_3 of { happy_var_3 -> + happyIn178+ (Alt (happy_var_1 <> happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** snd happy_var_3) happy_var_1 happy_var_2 (fst happy_var_3)+ )}}}++happyReduce_483 = happySpecReduce_2 168# happyReduction_483+happyReduction_483 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 RightArrow) -> + case happyOut139 happy_x_2 of { happy_var_2 -> + happyIn179+ (UnGuardedAlt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_484 = happySpecReduce_1 168# happyReduction_484+happyReduction_484 happy_x_1+ = case happyOut180 happy_x_1 of { happy_var_1 -> + happyIn179+ (GuardedAlts (snd happy_var_1) (reverse $ fst happy_var_1)+ )}++happyReduce_485 = happySpecReduce_2 169# happyReduction_485+happyReduction_485 happy_x_2+ happy_x_1+ = case happyOut180 happy_x_1 of { happy_var_1 -> + case happyOut181 happy_x_2 of { happy_var_2 -> + happyIn180+ ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)+ )}}++happyReduce_486 = happySpecReduce_1 169# happyReduction_486+happyReduction_486 happy_x_1+ = case happyOut181 happy_x_1 of { happy_var_1 -> + happyIn180+ (([happy_var_1], ann happy_var_1)+ )}++happyReduce_487 = happyMonadReduce 4# 170# happyReduction_487+happyReduction_487 (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 { (Loc happy_var_1 Bar) -> + case happyOut173 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> + case happyOut139 happy_x_4 of { happy_var_4 -> + ( do { checkPatternGuards (fst happy_var_2);+ let {l = nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])};+ return (GuardedAlt l (reverse (fst happy_var_2)) happy_var_4) })}}}}+ ) (\r -> happyReturn (happyIn181 r))++happyReduce_488 = happyMonadReduce 1# 171# happyReduction_488+happyReduction_488 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)}+ ) (\r -> happyReturn (happyIn182 r))++happyReduce_489 = happyMonadReduce 2# 171# happyReduction_489+happyReduction_489 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + case happyOut150 happy_x_2 of { happy_var_2 -> + ( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}+ ) (\r -> happyReturn (happyIn182 r))++happyReduce_490 = happySpecReduce_3 172# happyReduction_490+happyReduction_490 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> + case happyOut184 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> + happyIn183+ ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+ )}}}++happyReduce_491 = happySpecReduce_3 172# happyReduction_491+happyReduction_491 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOut184 happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn183+ ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+ )}}}++happyReduce_492 = happySpecReduce_2 173# happyReduction_492+happyReduction_492 happy_x_2+ happy_x_1+ = case happyOut186 happy_x_1 of { happy_var_1 -> + case happyOut185 happy_x_2 of { happy_var_2 -> + happyIn184+ ((happy_var_1 : fst happy_var_2, snd happy_var_2)+ )}}++happyReduce_493 = happySpecReduce_2 173# happyReduction_493+happyReduction_493 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> + case happyOut184 happy_x_2 of { happy_var_2 -> + happyIn184+ ((fst happy_var_2, happy_var_1 : snd happy_var_2)+ )}}++happyReduce_494 = happySpecReduce_0 173# happyReduction_494+happyReduction_494 = happyIn184+ (([],[])+ )++happyReduce_495 = happySpecReduce_2 174# happyReduction_495+happyReduction_495 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> + case happyOut184 happy_x_2 of { happy_var_2 -> + happyIn185+ ((fst happy_var_2, happy_var_1 : snd happy_var_2)+ )}}++happyReduce_496 = happySpecReduce_0 174# happyReduction_496+happyReduction_496 = happyIn185+ (([],[])+ )++happyReduce_497 = happySpecReduce_2 175# happyReduction_497+happyReduction_497 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn186+ (LetStmt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+ )}}++happyReduce_498 = happySpecReduce_3 175# happyReduction_498+happyReduction_498 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut182 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> + case happyOut139 happy_x_3 of { happy_var_3 -> + happyIn186+ (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_499 = happySpecReduce_1 175# happyReduction_499+happyReduction_499 happy_x_1+ = case happyOut139 happy_x_1 of { happy_var_1 -> + happyIn186+ (Qualifier (ann happy_var_1) happy_var_1+ )}++happyReduce_500 = happySpecReduce_2 175# happyReduction_500+happyReduction_500 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> + case happyOut183 happy_x_2 of { happy_var_2 -> + happyIn186+ (let (stms,inf,ss) = happy_var_2 in RecStmt (nIS happy_var_1 <++> inf <** happy_var_1:ss) stms+ )}}++happyReduce_501 = happySpecReduce_3 176# happyReduction_501+happyReduction_501 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut187 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> + case happyOut188 happy_x_3 of { happy_var_3 -> + happyIn187+ (let (fbs, ss) = happy_var_1 in (happy_var_3 : fbs, happy_var_2 : ss)+ )}}}++happyReduce_502 = happySpecReduce_1 176# happyReduction_502+happyReduction_502 happy_x_1+ = case happyOut188 happy_x_1 of { happy_var_1 -> + happyIn187+ (([happy_var_1],[])+ )}++happyReduce_503 = happySpecReduce_3 177# happyReduction_503+happyReduction_503 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut195 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn188+ (FieldUpdate (happy_var_1 <>happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_504 = happyMonadReduce 1# 177# happyReduction_504+happyReduction_504 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut195 happy_x_1 of { happy_var_1 -> + ( checkEnabled NamedFieldPuns >> checkUnQual happy_var_1 >>= return . FieldPun (ann happy_var_1))}+ ) (\r -> happyReturn (happyIn188 r))++happyReduce_505 = happyMonadReduce 1# 177# happyReduction_505+happyReduction_505 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DotDot) -> + ( checkEnabled RecordWildCards >> return (FieldWildcard (nIS happy_var_1)))}+ ) (\r -> happyReturn (happyIn188 r))++happyReduce_506 = happySpecReduce_3 178# happyReduction_506+happyReduction_506 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut190 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn189+ ((reverse (fst happy_var_2), reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+ )}}}++happyReduce_507 = happySpecReduce_3 179# happyReduction_507+happyReduction_507 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut190 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut191 happy_x_3 of { happy_var_3 -> + happyIn190+ ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+ )}}}++happyReduce_508 = happySpecReduce_1 179# happyReduction_508+happyReduction_508 happy_x_1+ = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn190+ (([happy_var_1],[])+ )}++happyReduce_509 = happySpecReduce_3 180# happyReduction_509+happyReduction_509 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut196 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> + case happyOut139 happy_x_3 of { happy_var_3 -> + happyIn191+ (IPBind (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+ )}}}++happyReduce_510 = happySpecReduce_2 181# happyReduction_510+happyReduction_510 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> + happyIn192+ (p_unit_con (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+ )}}++happyReduce_511 = happySpecReduce_2 181# happyReduction_511+happyReduction_511 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> + happyIn192+ (List (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2]) []+ )}}++happyReduce_512 = happySpecReduce_3 181# happyReduction_512+happyReduction_512 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn192+ (p_tuple_con (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Boxed (length happy_var_2)+ )}}}++happyReduce_513 = happySpecReduce_2 181# happyReduction_513+happyReduction_513 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> + case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> + happyIn192+ (p_unboxed_singleton_con (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+ )}}++happyReduce_514 = happySpecReduce_3 181# happyReduction_514+happyReduction_514 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> + case happyOut153 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> + happyIn192+ (p_tuple_con (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Unboxed (length happy_var_2)+ )}}}++happyReduce_515 = happySpecReduce_1 181# happyReduction_515+happyReduction_515 happy_x_1+ = case happyOut198 happy_x_1 of { happy_var_1 -> + happyIn192+ (Con (ann happy_var_1) happy_var_1+ )}++happyReduce_516 = happySpecReduce_1 182# happyReduction_516+happyReduction_516 happy_x_1+ = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn193+ (happy_var_1+ )}++happyReduce_517 = happySpecReduce_3 182# happyReduction_517+happyReduction_517 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut218 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn193+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_518 = happySpecReduce_1 183# happyReduction_518+happyReduction_518 happy_x_1+ = case happyOut209 happy_x_1 of { happy_var_1 -> + happyIn194+ (happy_var_1+ )}++happyReduce_519 = happySpecReduce_3 183# happyReduction_519+happyReduction_519 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut218 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn194+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_520 = happySpecReduce_1 184# happyReduction_520+happyReduction_520 happy_x_1+ = case happyOut208 happy_x_1 of { happy_var_1 -> + happyIn195+ (happy_var_1+ )}++happyReduce_521 = happySpecReduce_3 184# happyReduction_521+happyReduction_521 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn195+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_522 = happySpecReduce_1 185# happyReduction_522+happyReduction_522 happy_x_1+ = case happyOut211 happy_x_1 of { happy_var_1 -> + happyIn196+ (happy_var_1+ )}++happyReduce_523 = happySpecReduce_1 186# happyReduction_523+happyReduction_523 happy_x_1+ = case happyOut213 happy_x_1 of { happy_var_1 -> + happyIn197+ (happy_var_1+ )}++happyReduce_524 = happySpecReduce_3 186# happyReduction_524+happyReduction_524 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut215 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn197+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_525 = happySpecReduce_1 187# happyReduction_525+happyReduction_525 happy_x_1+ = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn198+ (happy_var_1+ )}++happyReduce_526 = happySpecReduce_3 187# happyReduction_526+happyReduction_526 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> + case happyOut207 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> + happyIn198+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_527 = happySpecReduce_1 188# happyReduction_527+happyReduction_527 happy_x_1+ = case happyOut218 happy_x_1 of { happy_var_1 -> + happyIn199+ (happy_var_1+ )}++happyReduce_528 = happySpecReduce_3 188# happyReduction_528+happyReduction_528 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut210 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn199+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_529 = happySpecReduce_1 189# happyReduction_529+happyReduction_529 happy_x_1+ = case happyOut216 happy_x_1 of { happy_var_1 -> + happyIn200+ (happy_var_1+ )}++happyReduce_530 = happySpecReduce_3 189# happyReduction_530+happyReduction_530 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut208 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn200+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_531 = happySpecReduce_1 190# happyReduction_531+happyReduction_531 happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + happyIn201+ (happy_var_1+ )}++happyReduce_532 = happySpecReduce_3 190# happyReduction_532+happyReduction_532 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut208 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn201+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_533 = happySpecReduce_1 191# happyReduction_533+happyReduction_533 happy_x_1+ = case happyOut215 happy_x_1 of { happy_var_1 -> + happyIn202+ (happy_var_1+ )}++happyReduce_534 = happySpecReduce_3 191# happyReduction_534+happyReduction_534 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut213 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn202+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_535 = happySpecReduce_1 192# happyReduction_535+happyReduction_535 happy_x_1+ = case happyOut207 happy_x_1 of { happy_var_1 -> + happyIn203+ (happy_var_1+ )}++happyReduce_536 = happySpecReduce_3 192# happyReduction_536+happyReduction_536 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut212 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn203+ (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+ )}}}++happyReduce_537 = happySpecReduce_1 193# happyReduction_537+happyReduction_537 happy_x_1+ = case happyOut199 happy_x_1 of { happy_var_1 -> + happyIn204+ (VarOp (ann happy_var_1) happy_var_1+ )}++happyReduce_538 = happySpecReduce_1 193# happyReduction_538+happyReduction_538 happy_x_1+ = case happyOut202 happy_x_1 of { happy_var_1 -> + happyIn204+ (ConOp (ann happy_var_1) happy_var_1+ )}++happyReduce_539 = happySpecReduce_1 194# happyReduction_539+happyReduction_539 happy_x_1+ = case happyOut200 happy_x_1 of { happy_var_1 -> + happyIn205+ (QVarOp (ann happy_var_1) happy_var_1+ )}++happyReduce_540 = happySpecReduce_1 194# happyReduction_540+happyReduction_540 happy_x_1+ = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn205+ (QConOp (ann happy_var_1) happy_var_1+ )}++happyReduce_541 = happySpecReduce_1 195# happyReduction_541+happyReduction_541 happy_x_1+ = case happyOut201 happy_x_1 of { happy_var_1 -> + happyIn206+ (QVarOp (ann happy_var_1) happy_var_1+ )}++happyReduce_542 = happySpecReduce_1 195# happyReduction_542+happyReduction_542 happy_x_1+ = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn206+ (QConOp (ann happy_var_1) happy_var_1+ )}++happyReduce_543 = happySpecReduce_1 196# happyReduction_543+happyReduction_543 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Colon) -> + happyIn207+ (list_cons_name (nIS happy_var_1)+ )}++happyReduce_544 = happySpecReduce_1 196# happyReduction_544+happyReduction_544 happy_x_1+ = case happyOut214 happy_x_1 of { happy_var_1 -> + happyIn207+ (happy_var_1+ )}++happyReduce_545 = happySpecReduce_1 197# happyReduction_545+happyReduction_545 happy_x_1+ = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn208+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_546 = happySpecReduce_1 197# happyReduction_546+happyReduction_546 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn208+ (let {Loc l (QVarId q) = happy_var_1; nis = nIS l}+ in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))+ )}++happyReduce_547 = happySpecReduce_1 198# happyReduction_547+happyReduction_547 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn209+ (let Loc l (VarId v) = happy_var_1 in Ident (nIS l) v+ )}++happyReduce_548 = happySpecReduce_1 198# happyReduction_548+happyReduction_548 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> + happyIn209+ (as_name (nIS happy_var_1)+ )}++happyReduce_549 = happySpecReduce_1 198# happyReduction_549+happyReduction_549 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> + happyIn209+ (qualified_name (nIS happy_var_1)+ )}++happyReduce_550 = happySpecReduce_1 198# happyReduction_550+happyReduction_550 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> + happyIn209+ (hiding_name (nIS happy_var_1)+ )}++happyReduce_551 = happySpecReduce_1 198# happyReduction_551+happyReduction_551 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> + happyIn209+ (export_name (nIS happy_var_1)+ )}++happyReduce_552 = happySpecReduce_1 198# happyReduction_552+happyReduction_552 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> + happyIn209+ (stdcall_name (nIS happy_var_1)+ )}++happyReduce_553 = happySpecReduce_1 198# happyReduction_553+happyReduction_553 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> + happyIn209+ (ccall_name (nIS happy_var_1)+ )}++happyReduce_554 = happySpecReduce_1 199# happyReduction_554+happyReduction_554 happy_x_1+ = case happyOut209 happy_x_1 of { happy_var_1 -> + happyIn210+ (happy_var_1+ )}++happyReduce_555 = happySpecReduce_1 199# happyReduction_555+happyReduction_555 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> + happyIn210+ (safe_name (nIS happy_var_1)+ )}++happyReduce_556 = happySpecReduce_1 199# happyReduction_556+happyReduction_556 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> + happyIn210+ (unsafe_name (nIS happy_var_1)+ )}++happyReduce_557 = happySpecReduce_1 199# happyReduction_557+happyReduction_557 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> + happyIn210+ (threadsafe_name (nIS happy_var_1)+ )}++happyReduce_558 = happySpecReduce_1 200# happyReduction_558+happyReduction_558 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn211+ (let Loc l (IDupVarId i) = happy_var_1 in IPDup (nIS l) i+ )}++happyReduce_559 = happySpecReduce_1 200# happyReduction_559+happyReduction_559 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn211+ (let Loc l (ILinVarId i) = happy_var_1 in IPLin (nIS l) i+ )}++happyReduce_560 = happySpecReduce_1 201# happyReduction_560+happyReduction_560 happy_x_1+ = case happyOut213 happy_x_1 of { happy_var_1 -> + happyIn212+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_561 = happySpecReduce_1 201# happyReduction_561+happyReduction_561 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn212+ (let {Loc l (QConId q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))+ )}++happyReduce_562 = happySpecReduce_1 202# happyReduction_562+happyReduction_562 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn213+ (let Loc l (ConId c) = happy_var_1 in Ident (nIS l) c+ )}++happyReduce_563 = happySpecReduce_1 203# happyReduction_563+happyReduction_563 happy_x_1+ = case happyOut215 happy_x_1 of { happy_var_1 -> + happyIn214+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_564 = happySpecReduce_1 203# happyReduction_564+happyReduction_564 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn214+ (let {Loc l (QConSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))+ )}++happyReduce_565 = happySpecReduce_1 204# happyReduction_565+happyReduction_565 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn215+ (let Loc l (ConSym c) = happy_var_1 in Symbol (nIS l) c+ )}++happyReduce_566 = happySpecReduce_1 205# happyReduction_566+happyReduction_566 happy_x_1+ = case happyOut218 happy_x_1 of { happy_var_1 -> + happyIn216+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_567 = happySpecReduce_1 205# happyReduction_567+happyReduction_567 happy_x_1+ = case happyOut220 happy_x_1 of { happy_var_1 -> + happyIn216+ (happy_var_1+ )}++happyReduce_568 = happySpecReduce_1 206# happyReduction_568+happyReduction_568 happy_x_1+ = case happyOut219 happy_x_1 of { happy_var_1 -> + happyIn217+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_569 = happySpecReduce_1 206# happyReduction_569+happyReduction_569 happy_x_1+ = case happyOut220 happy_x_1 of { happy_var_1 -> + happyIn217+ (happy_var_1+ )}++happyReduce_570 = happySpecReduce_1 207# happyReduction_570+happyReduction_570 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn218+ (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v+ )}++happyReduce_571 = happySpecReduce_1 207# happyReduction_571+happyReduction_571 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> + happyIn218+ (minus_name (nIS happy_var_1)+ )}++happyReduce_572 = happySpecReduce_1 207# happyReduction_572+happyReduction_572 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + happyIn218+ (bang_name (nIS happy_var_1)+ )}++happyReduce_573 = happySpecReduce_1 207# happyReduction_573+happyReduction_573 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> + happyIn218+ (dot_name (nIS happy_var_1)+ )}++happyReduce_574 = happySpecReduce_1 207# happyReduction_574+happyReduction_574 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> + happyIn218+ (star_name (nIS happy_var_1)+ )}++happyReduce_575 = happySpecReduce_1 208# happyReduction_575+happyReduction_575 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn219+ (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v+ )}++happyReduce_576 = happySpecReduce_1 208# happyReduction_576+happyReduction_576 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> + happyIn219+ (bang_name (nIS happy_var_1)+ )}++happyReduce_577 = happySpecReduce_1 208# happyReduction_577+happyReduction_577 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> + happyIn219+ (dot_name (nIS happy_var_1)+ )}++happyReduce_578 = happySpecReduce_1 208# happyReduction_578+happyReduction_578 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> + happyIn219+ (star_name (nIS happy_var_1)+ )}++happyReduce_579 = happySpecReduce_1 209# happyReduction_579+happyReduction_579 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn220+ (let {Loc l (QVarSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))+ )}++happyReduce_580 = happySpecReduce_1 210# happyReduction_580+happyReduction_580 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (IntTok (i,raw)) = happy_var_1 in Int (nIS l) i raw+ )}++happyReduce_581 = happySpecReduce_1 210# happyReduction_581+happyReduction_581 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (Character (c,raw)) = happy_var_1 in Char (nIS l) c raw+ )}++happyReduce_582 = happySpecReduce_1 210# happyReduction_582+happyReduction_582 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (FloatTok (r,raw)) = happy_var_1 in Frac (nIS l) r raw+ )}++happyReduce_583 = happySpecReduce_1 210# happyReduction_583+happyReduction_583 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (StringTok (s,raw)) = happy_var_1 in String (nIS l) s raw+ )}++happyReduce_584 = happySpecReduce_1 210# happyReduction_584+happyReduction_584 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (IntTokHash (i,raw)) = happy_var_1 in PrimInt (nIS l) i raw+ )}++happyReduce_585 = happySpecReduce_1 210# happyReduction_585+happyReduction_585 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (WordTokHash (w,raw)) = happy_var_1 in PrimWord (nIS l) w raw+ )}++happyReduce_586 = happySpecReduce_1 210# happyReduction_586+happyReduction_586 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (FloatTokHash (f,raw)) = happy_var_1 in PrimFloat (nIS l) f raw+ )}++happyReduce_587 = happySpecReduce_1 210# happyReduction_587+happyReduction_587 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (DoubleTokHash (d,raw)) = happy_var_1 in PrimDouble (nIS l) d raw+ )}++happyReduce_588 = happySpecReduce_1 210# happyReduction_588+happyReduction_588 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (CharacterHash (c,raw)) = happy_var_1 in PrimChar (nIS l) c raw+ )}++happyReduce_589 = happySpecReduce_1 210# happyReduction_589+happyReduction_589 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn221+ (let Loc l (StringHash (s,raw)) = happy_var_1 in PrimString (nIS l) s raw+ )}++happyReduce_590 = happyMonadReduce 0# 211# happyReduction_590+happyReduction_590 (happyRest) tk+ = happyThen (( pushCurrentContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x) (return x) -})+ ) (\r -> happyReturn (happyIn222 r))++happyReduce_591 = happySpecReduce_1 212# happyReduction_591+happyReduction_591 happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 VRightCurly) -> + happyIn223+ (happy_var_1 {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -}+ )}++happyReduce_592 = happyMonadReduce 1# 212# happyReduction_592+happyReduction_592 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (( popContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x ++ show x) (return x) -})+ ) (\r -> happyReturn (happyIn223 r))++happyReduce_593 = happySpecReduce_1 213# happyReduction_593+happyReduction_593 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn224+ (let Loc l (ConId n) = happy_var_1 in ModuleName (nIS l) n+ )}++happyReduce_594 = happySpecReduce_1 213# happyReduction_594+happyReduction_594 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn224+ (let Loc l (QConId n) = happy_var_1 in ModuleName (nIS l) (fst n ++ '.':snd n)+ )}++happyReduce_595 = happySpecReduce_1 214# happyReduction_595+happyReduction_595 happy_x_1+ = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn225+ (happy_var_1+ )}++happyReduce_596 = happySpecReduce_1 215# happyReduction_596+happyReduction_596 happy_x_1+ = case happyOut198 happy_x_1 of { happy_var_1 -> + happyIn226+ (happy_var_1+ )}++happyReduce_597 = happySpecReduce_1 216# happyReduction_597+happyReduction_597 happy_x_1+ = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn227+ (happy_var_1+ )}++happyReduce_598 = happySpecReduce_3 217# happyReduction_598+happyReduction_598 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> + case happyOut227 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> + happyIn228+ (UnQual (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3]) happy_var_2+ )}}}++happyReduce_599 = happySpecReduce_1 217# happyReduction_599+happyReduction_599 happy_x_1+ = case happyOut229 happy_x_1 of { happy_var_1 -> + happyIn228+ (UnQual (ann happy_var_1) happy_var_1+ )}++happyReduce_600 = happySpecReduce_1 218# happyReduction_600+happyReduction_600 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn229+ (let Loc l (VarSym x) = happy_var_1 in Symbol (nIS l) x+ )}++happyNewToken action sts stk+ = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in+ case tk of {+ Loc _ EOF -> happyDoAction 137# tk action sts stk;+ Loc _ (VarId _) -> cont 1#;+ Loc _ (QVarId _) -> cont 2#;+ Loc _ (IDupVarId _) -> cont 3#;+ Loc _ (ILinVarId _) -> cont 4#;+ Loc _ (ConId _) -> cont 5#;+ Loc _ (QConId _) -> cont 6#;+ Loc _ (DVarId _) -> cont 7#;+ Loc _ (VarSym _) -> cont 8#;+ Loc _ (ConSym _) -> cont 9#;+ Loc _ (QVarSym _) -> cont 10#;+ Loc _ (QConSym _) -> cont 11#;+ Loc _ (IntTok _) -> cont 12#;+ Loc _ (FloatTok _) -> cont 13#;+ Loc _ (Character _) -> cont 14#;+ Loc _ (StringTok _) -> cont 15#;+ Loc _ (IntTokHash _) -> cont 16#;+ Loc _ (WordTokHash _) -> cont 17#;+ Loc _ (FloatTokHash _) -> cont 18#;+ Loc _ (DoubleTokHash _) -> cont 19#;+ Loc _ (CharacterHash _) -> cont 20#;+ Loc _ (StringHash _) -> cont 21#;+ Loc happy_dollar_dollar LeftParen -> cont 22#;+ Loc happy_dollar_dollar RightParen -> cont 23#;+ Loc happy_dollar_dollar LeftHashParen -> cont 24#;+ Loc happy_dollar_dollar RightHashParen -> cont 25#;+ Loc happy_dollar_dollar LeftCurlyBar -> cont 26#;+ Loc happy_dollar_dollar RightCurlyBar -> cont 27#;+ Loc happy_dollar_dollar SemiColon -> cont 28#;+ Loc happy_dollar_dollar LeftCurly -> cont 29#;+ Loc happy_dollar_dollar RightCurly -> cont 30#;+ Loc happy_dollar_dollar VRightCurly -> cont 31#;+ Loc happy_dollar_dollar LeftSquare -> cont 32#;+ Loc happy_dollar_dollar RightSquare -> cont 33#;+ Loc happy_dollar_dollar Comma -> cont 34#;+ Loc happy_dollar_dollar DoubleUnderscore -> cont 35#;+ Loc happy_dollar_dollar Underscore -> cont 36#;+ Loc happy_dollar_dollar BackQuote -> cont 37#;+ Loc happy_dollar_dollar Dot -> cont 38#;+ Loc happy_dollar_dollar DotDot -> cont 39#;+ Loc happy_dollar_dollar Colon -> cont 40#;+ Loc happy_dollar_dollar DoubleColon -> cont 41#;+ Loc happy_dollar_dollar Equals -> cont 42#;+ Loc happy_dollar_dollar Backslash -> cont 43#;+ Loc happy_dollar_dollar Bar -> cont 44#;+ Loc happy_dollar_dollar LeftArrow -> cont 45#;+ Loc happy_dollar_dollar RightArrow -> cont 46#;+ Loc happy_dollar_dollar At -> cont 47#;+ Loc happy_dollar_dollar Tilde -> cont 48#;+ Loc happy_dollar_dollar DoubleArrow -> cont 49#;+ Loc happy_dollar_dollar Minus -> cont 50#;+ Loc happy_dollar_dollar Exclamation -> cont 51#;+ Loc happy_dollar_dollar Star -> cont 52#;+ Loc happy_dollar_dollar LeftArrowTail -> cont 53#;+ Loc happy_dollar_dollar RightArrowTail -> cont 54#;+ Loc happy_dollar_dollar LeftDblArrowTail -> cont 55#;+ Loc happy_dollar_dollar RightDblArrowTail -> cont 56#;+ Loc happy_dollar_dollar RPGuardOpen -> cont 57#;+ Loc happy_dollar_dollar RPGuardClose -> cont 58#;+ Loc happy_dollar_dollar RPCAt -> cont 59#;+ Loc _ (THIdEscape _) -> cont 60#;+ Loc happy_dollar_dollar THParenEscape -> cont 61#;+ Loc happy_dollar_dollar THExpQuote -> cont 62#;+ Loc happy_dollar_dollar THPatQuote -> cont 63#;+ Loc happy_dollar_dollar THTypQuote -> cont 64#;+ Loc happy_dollar_dollar THDecQuote -> cont 65#;+ Loc happy_dollar_dollar THCloseQuote -> cont 66#;+ Loc happy_dollar_dollar THVarQuote -> cont 67#;+ Loc happy_dollar_dollar THTyQuote -> cont 68#;+ Loc _ (THQuasiQuote _) -> cont 69#;+ Loc happy_dollar_dollar FSContextOpen -> cont 70#;+ Loc happy_dollar_dollar FSContextClose -> cont 71#;+ Loc _ (XPCDATA _) -> cont 72#;+ Loc happy_dollar_dollar XStdTagOpen -> cont 73#;+ Loc happy_dollar_dollar XCloseTagOpen -> cont 74#;+ Loc happy_dollar_dollar XCodeTagOpen -> cont 75#;+ Loc happy_dollar_dollar XChildTagOpen -> cont 76#;+ Loc happy_dollar_dollar XStdTagClose -> cont 77#;+ Loc happy_dollar_dollar XEmptyTagClose -> cont 78#;+ Loc happy_dollar_dollar XCodeTagClose -> cont 79#;+ Loc happy_dollar_dollar XRPatOpen -> cont 80#;+ Loc happy_dollar_dollar XRPatClose -> cont 81#;+ Loc happy_dollar_dollar KW_Foreign -> cont 82#;+ Loc happy_dollar_dollar KW_Export -> cont 83#;+ Loc happy_dollar_dollar KW_Safe -> cont 84#;+ Loc happy_dollar_dollar KW_Unsafe -> cont 85#;+ Loc happy_dollar_dollar KW_Threadsafe -> cont 86#;+ Loc happy_dollar_dollar KW_StdCall -> cont 87#;+ Loc happy_dollar_dollar KW_CCall -> cont 88#;+ Loc happy_dollar_dollar KW_As -> cont 89#;+ Loc happy_dollar_dollar KW_By -> cont 90#;+ Loc happy_dollar_dollar KW_Case -> cont 91#;+ Loc happy_dollar_dollar KW_Class -> cont 92#;+ Loc happy_dollar_dollar KW_Data -> cont 93#;+ Loc happy_dollar_dollar KW_Default -> cont 94#;+ Loc happy_dollar_dollar KW_Deriving -> cont 95#;+ Loc happy_dollar_dollar KW_Do -> cont 96#;+ Loc happy_dollar_dollar KW_Else -> cont 97#;+ Loc happy_dollar_dollar KW_Family -> cont 98#;+ Loc happy_dollar_dollar KW_Forall -> cont 99#;+ Loc happy_dollar_dollar KW_Group -> cont 100#;+ Loc happy_dollar_dollar KW_Hiding -> cont 101#;+ Loc happy_dollar_dollar KW_If -> cont 102#;+ Loc happy_dollar_dollar KW_Import -> cont 103#;+ Loc happy_dollar_dollar KW_In -> cont 104#;+ Loc happy_dollar_dollar KW_Infix -> cont 105#;+ Loc happy_dollar_dollar KW_InfixL -> cont 106#;+ Loc happy_dollar_dollar KW_InfixR -> cont 107#;+ Loc happy_dollar_dollar KW_Instance -> cont 108#;+ Loc happy_dollar_dollar KW_Let -> cont 109#;+ Loc happy_dollar_dollar KW_MDo -> cont 110#;+ Loc happy_dollar_dollar KW_Module -> cont 111#;+ Loc happy_dollar_dollar KW_NewType -> cont 112#;+ Loc happy_dollar_dollar KW_Of -> cont 113#;+ Loc happy_dollar_dollar KW_Proc -> cont 114#;+ Loc happy_dollar_dollar KW_Rec -> cont 115#;+ Loc happy_dollar_dollar KW_Then -> cont 116#;+ Loc happy_dollar_dollar KW_Type -> cont 117#;+ Loc happy_dollar_dollar KW_Using -> cont 118#;+ Loc happy_dollar_dollar KW_Where -> cont 119#;+ Loc happy_dollar_dollar KW_Qualified -> cont 120#;+ Loc _ (INLINE _) -> cont 121#;+ Loc happy_dollar_dollar INLINE_CONLIKE -> cont 122#;+ Loc happy_dollar_dollar SPECIALISE -> cont 123#;+ Loc _ (SPECIALISE_INLINE _) -> cont 124#;+ Loc happy_dollar_dollar SOURCE -> cont 125#;+ Loc happy_dollar_dollar RULES -> cont 126#;+ Loc happy_dollar_dollar CORE -> cont 127#;+ Loc happy_dollar_dollar SCC -> cont 128#;+ Loc happy_dollar_dollar GENERATED -> cont 129#;+ Loc happy_dollar_dollar DEPRECATED -> cont 130#;+ Loc happy_dollar_dollar WARNING -> cont 131#;+ Loc happy_dollar_dollar UNPACK -> cont 132#;+ Loc _ (OPTIONS _) -> cont 133#;+ Loc happy_dollar_dollar LANGUAGE -> cont 134#;+ Loc happy_dollar_dollar ANN -> cont 135#;+ Loc happy_dollar_dollar PragmaEnd -> cont 136#;+ _ -> happyError' tk+ })++happyError_ tk = happyError' tk++happyThen :: () => P a -> (a -> P b) -> P b+happyThen = (>>=)+happyReturn :: () => a -> P a+happyReturn = (return)+happyThen1 = happyThen+happyReturn1 :: () => a -> P a+happyReturn1 = happyReturn+happyError' :: () => (Loc Token) -> P a+happyError' tk = parseError tk++mparseModule = happySomeParser where+ happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut13 x))++mparseExp = happySomeParser where+ happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut139 x))++mparsePat = happySomeParser where+ happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut182 x))++mparseDecl = happySomeParser where+ happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut50 x))++mparseType = happySomeParser where+ happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut88 x))++mparseStmt = happySomeParser where+ happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut186 x))++mparseModules = happySomeParser where+ happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut11 x))++mfindOptPragmas = happySomeParser where+ happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut15 x))++happySeq = happyDontSeq+++type L = SrcSpanInfo -- just for convenience+type S = SrcSpan++parseError :: Loc Token -> P a+parseError t = fail $ "Parse error: " ++ showToken (unLoc t)++(<>) :: (Annotated a, Annotated b) => a SrcSpanInfo -> b SrcSpanInfo -> SrcSpanInfo+a <> b = ann a <++> ann b+infixl 6 <>++nIS = noInfoSpan+iS = infoSpan+++-- | Parse of a string, which should contain a complete Haskell module.+parseModule :: String -> ParseResult (Module SrcSpanInfo)+parseModule = simpleParse mparseModule++-- | Parse of a string containing a complete Haskell module, using an explicit mode.+parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)+parseModuleWithMode = modeParse mparseModule++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])+parseModuleWithComments = commentParse mparseModule++-- | Parse of a string containing a Haskell expression.+parseExp :: String -> ParseResult (Exp SrcSpanInfo)+parseExp = simpleParse mparseExp++-- | Parse of a string containing a Haskell expression, using an explicit mode.+parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)+parseExpWithMode = modeParse mparseExp++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])+parseExpWithComments = commentParse mparseExp++-- | Parse of a string containing a Haskell pattern.+parsePat :: String -> ParseResult (Pat SrcSpanInfo)+parsePat = simpleParse mparsePat++-- | Parse of a string containing a Haskell pattern, using an explicit mode.+parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)+parsePatWithMode = modeParse mparsePat++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])+parsePatWithComments = commentParse mparsePat++-- | Parse of a string containing a Haskell top-level declaration.+parseDecl :: String -> ParseResult (Decl SrcSpanInfo)+parseDecl = simpleParse mparseDecl++-- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.+parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)+parseDeclWithMode = modeParse mparseDecl++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])+parseDeclWithComments = commentParse mparseDecl++-- | Parse of a string containing a Haskell type.+parseType :: String -> ParseResult (Type SrcSpanInfo)+parseType = runParser mparseType++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)+parseTypeWithMode mode = runParserWithMode mode mparseType++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])+parseTypeWithComments mode str = runParserWithModeComments mode mparseType str++-- | Parse of a string containing a Haskell statement.+parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)+parseStmt = runParser mparseStmt++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)+parseStmtWithMode mode = runParserWithMode mode mparseStmt++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])+parseStmtWithComments mode str = runParserWithModeComments mode mparseStmt str+++simpleParse :: AppFixity a => P (a L) -> String -> ParseResult (a L)+simpleParse p = applyFixities preludeFixities <=< runParser p++modeParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L)+modeParse p mode = applyFixities' (fixities mode) <=< runParserWithMode mode p++commentParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L, [Comment])+commentParse p mode str = do (ast, cs) <- runParserWithModeComments mode p str+ ast' <- applyFixities' (fixities mode) ast+ return (ast', cs)++-- | Partial parse of a string starting with a series of top-level option pragmas.+getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]+getTopPragmas = runParser (mfindOptPragmas >>= \(ps,_,_) -> return ps)++-- | Parse of a string, which should contain a complete Haskell module.+parseModules :: String -> ParseResult [Module SrcSpanInfo]+parseModules = mapM (applyFixities preludeFixities) <=< runParser mparseModules++-- | Parse of a string containing a complete Haskell module, using an explicit mode.+parseModulesWithMode :: ParseMode -> String -> ParseResult [Module SrcSpanInfo]+parseModulesWithMode mode = mapM (applyFixities' (fixities mode)) <=< runParserWithMode mode mparseModules++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseModulesWithComments :: ParseMode -> String -> ParseResult ([Module SrcSpanInfo], [Comment])+parseModulesWithComments mode str = do (ast,cs) <- runParserWithModeComments mode mparseModules str+ ast' <- mapM (applyFixities' (fixities mode)) ast+ return (ast', cs)+applyFixities' :: (AppFixity a) => Maybe [Fixity] -> a L -> ParseResult (a L)+applyFixities' Nothing ast = return ast+applyFixities' (Just fixs) ast = applyFixities fixs ast+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command-line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp ++{-# LINE 30 "templates/GenericTemplate.hs" #-}+++data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList++++++{-# LINE 51 "templates/GenericTemplate.hs" #-}++{-# LINE 61 "templates/GenericTemplate.hs" #-}++{-# LINE 70 "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 i tk st+ -1# -> {- nothing -}+ happyAccept i tk st+ n | (n Happy_GHC_Exts.<# (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) = indexShortOffAddr happyActOffsets st+ (off_i) = (off Happy_GHC_Exts.+# i)+ check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))+ then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i)+ else False+ (action)+ | check = indexShortOffAddr happyTable off_i+ | otherwise = indexShortOffAddr happyDefActions st++{-# LINE 130 "templates/GenericTemplate.hs" #-}+++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#++++++data HappyAddr = HappyA# Happy_GHC_Exts.Addr#+++++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++{-# LINE 163 "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 =+ happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))+ where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))+ drop_stk = happyDropStk k 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 =+ happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))+ where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))+ drop_stk = happyDropStk k stk++ (off) = indexShortOffAddr happyGotoOffsets st1+ (off_i) = (off Happy_GHC_Exts.+# nt)+ (new_state) = indexShortOffAddr happyTable off_i+++++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) = 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 0# tk old_st _ stk =+-- trace "failing" $ + happyError_ 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 i tk (action) sts stk =+-- trace "entering error recovery" $+ happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)++-- Internal happy errors:++notHappyAtAll :: a+notHappyAtAll = error "Internal Happy error\n"++-----------------------------------------------------------------------------+-- Hack to get the typechecker to accept our action functions+++happyTcHack :: Happy_GHC_Exts.Int# -> a -> a+happyTcHack x y = y+{-# INLINE happyTcHack #-}+++-----------------------------------------------------------------------------+-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq+-- otherwise it emits+-- happySeq = happyDontSeq++happyDoSeq, happyDontSeq :: a -> b -> b+happyDoSeq a b = a `seq` b+happyDontSeq a b = b++-----------------------------------------------------------------------------+-- Don't inline any functions from the template. GHC has a nasty habit+-- of deciding to inline happyGoto everywhere, which increases the size of+-- the generated parser quite a bit.+++{-# NOINLINE happyDoAction #-}+{-# NOINLINE happyTable #-}+{-# NOINLINE happyCheck #-}+{-# NOINLINE happyActOffsets #-}+{-# NOINLINE happyGotoOffsets #-}+{-# NOINLINE happyDefActions #-}++{-# NOINLINE happyShift #-}+{-# NOINLINE happySpecReduce_0 #-}+{-# NOINLINE happySpecReduce_1 #-}+{-# NOINLINE happySpecReduce_2 #-}+{-# NOINLINE happySpecReduce_3 #-}+{-# NOINLINE happyReduce #-}+{-# NOINLINE happyMonadReduce #-}+{-# NOINLINE happyGoto #-}+{-# NOINLINE happyFail #-}++-- end of Happy Template.
+ HSE/InternalParser.ly view
@@ -0,0 +1,1862 @@+> {+> {-# OPTIONS_HADDOCK hide #-}+> -----------------------------------------------------------------------------+> -- |+> -- Module : HSE.Annotated.Parser+> -- Copyright : (c) Niklas Broberg 2004-2009,+> -- Original (c) Simon Marlow, Sven Panne 1997-2000+> -- License : BSD-style (see the file LICENSE.txt)+> --+> -- Maintainer : Niklas Broberg, d00nibro@chalmers.se+> -- Stability : stable+> -- Portability : portable+> --+> --+> -----------------------------------------------------------------------------+>+> module HSE.InternalParser (+> -- * General parsing+> ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,+> -- * Parsing of specific AST elements+> -- ** Modules+> parseModule, parseModuleWithMode, parseModuleWithComments,+> -- ** Expressions+> parseExp, parseExpWithMode, parseExpWithComments,+> -- ** Statements+> parseStmt, parseStmtWithMode, parseStmtWithComments,+> -- ** Patterns+> parsePat, parsePatWithMode, parsePatWithComments,+> -- ** Declarations+> parseDecl, parseDeclWithMode, parseDeclWithComments,+> -- ** Types+> parseType, parseTypeWithMode, parseTypeWithComments,+> -- ** Multiple modules in one file+> parseModules, parseModulesWithMode, parseModulesWithComments,+> -- ** Option pragmas+> getTopPragmas+> ) where+>+> import HSE.Annotated.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) )+> import HSE.Annotated.Syntax ( Type, Exp, Asst )+> import HSE.ParseMonad+> import HSE.Lexer+> import HSE.ParseUtils+> import HSE.Annotated.Fixity+> import HSE.SrcLoc+> import HSE.Comments ( Comment )+> import HSE.Extension++> import Control.Monad ( liftM, (<=<) )+import Debug.Trace (trace)++> }++-----------------------------------------------------------------------------+This module comprises a parser for Haskell 98 with the following extensions++* Multi-parameter type classes with functional dependencies+* Implicit parameters+* Pattern guards+* Mdo notation+* FFI+* HaRP+* HSP++Most of the code is blatantly stolen from the GHC module Language.Haskell.Parser.+Some of the code for extensions is greatly influenced by GHC's internal parser+library, ghc/compiler/parser/Parser.y.+-----------------------------------------------------------------------------+Conflicts: 6 shift/reduce++2 for ambiguity in 'case x of y | let z = y in z :: Bool -> b' [State 12, 244]+ (don't know whether to reduce 'Bool' as a btype or shift the '->'.+ Similarly lambda and if. The default resolution in favour of the+ shift means that a guard can never end with a type signature.+ In mitigation: it's a rare case and no Haskell implementation+ allows these, because it would require unbounded lookahead.)+ There are 2 conflicts rather than one because contexts are parsed+ as btypes (cf ctype).++1 for ambiguity in 'let ?x ...' [State 712]+ the parser can't tell whether the ?x is the lhs of a normal binding or+ an implicit binding. Fortunately resolving as shift gives it the only+ sensible meaning, namely the lhs of an implicit binding.++1 for ambiguity using hybrid modules [State 116]+ For HSP pages that start with a <% %> block, the parser cannot tell whether+ to reduce a srcloc or shift the starting <%. Since any other body could not+ start with <%, shifting is the only sensible thing to do.++1 for ambiguity using toplevel xml modules [State 119]+ For HSP xml pages starting with a <, the parser cannot tell whether to shift+ that < or reduce an implicit 'open'. Since no other body could possibly start+ with <, shifting is the only sensible thing to do.++1 for ambiguity in '{-# RULES "name" [ ... #-}' [State 318]+ we don't know whether the '[' starts the activation or not: it+ might be the start of the declaration with the activation being+ empty. Resolving with shift means the declaration cannot start with '['.++-----------------------------------------------------------------------------++> %token+> VARID { Loc _ (VarId _) }+> QVARID { Loc _ (QVarId _) }+> IDUPID { Loc _ (IDupVarId _) } -- duplicable implicit parameter ?x+> ILINID { Loc _ (ILinVarId _) } -- linear implicit parameter %x+> CONID { Loc _ (ConId _) }+> QCONID { Loc _ (QConId _) }+> DVARID { Loc _ (DVarId _) } -- VARID containing dashes+> VARSYM { Loc _ (VarSym _) }+> CONSYM { Loc _ (ConSym _) }+> QVARSYM { Loc _ (QVarSym _) }+> QCONSYM { Loc _ (QConSym _) }+> INT { Loc _ (IntTok _) }+> RATIONAL { Loc _ (FloatTok _) }+> CHAR { Loc _ (Character _) }+> STRING { Loc _ (StringTok _) }++> PRIMINT { Loc _ (IntTokHash _) }+> PRIMWORD { Loc _ (WordTokHash _) }+> PRIMFLOAT { Loc _ (FloatTokHash _) }+> PRIMDOUBLE { Loc _ (DoubleTokHash _) }+> PRIMCHAR { Loc _ (CharacterHash _) }+> PRIMSTRING { Loc _ (StringHash _) }++Symbols++> '(' { Loc $$ LeftParen }+> ')' { Loc $$ RightParen }+> '(#' { Loc $$ LeftHashParen }+> '#)' { Loc $$ RightHashParen }+> '{|' { Loc $$ LeftCurlyBar }+> '|}' { Loc $$ RightCurlyBar }+> ';' { Loc $$ SemiColon }+> '{' { Loc $$ LeftCurly }+> '}' { Loc $$ RightCurly }+> vccurly { Loc $$ VRightCurly } -- a virtual close brace+> '[' { Loc $$ LeftSquare }+> ']' { Loc $$ RightSquare }+> ',' { Loc $$ Comma }+> '__' { Loc $$ DoubleUnderscore }+> '_' { Loc $$ Underscore }+> '`' { Loc $$ BackQuote }++Reserved operators++> '.' { Loc $$ Dot }+> '..' { Loc $$ DotDot }+> ':' { Loc $$ Colon }+> '::' { Loc $$ DoubleColon }+> '=' { Loc $$ Equals }+> '\\' { Loc $$ Backslash }+> '|' { Loc $$ Bar }+> '<-' { Loc $$ LeftArrow }+> '->' { Loc $$ RightArrow }+> '@' { Loc $$ At }+> '~' { Loc $$ Tilde }+> '=>' { Loc $$ DoubleArrow }+> '-' { Loc $$ Minus }+> '!' { Loc $$ Exclamation }+> '*' { Loc $$ Star }++Arrows++> '-<' { Loc $$ LeftArrowTail }+> '>-' { Loc $$ RightArrowTail }+> '-<<' { Loc $$ LeftDblArrowTail }+> '>>-' { Loc $$ RightDblArrowTail }++Harp++> '(|' { Loc $$ RPGuardOpen }+> '|)' { Loc $$ RPGuardClose }+> '@:' { Loc $$ RPCAt }++Template Haskell++> IDSPLICE { Loc _ (THIdEscape _) } -- $x+> '$(' { Loc $$ THParenEscape }+> '[|' { Loc $$ THExpQuote }+> '[p|' { Loc $$ THPatQuote }+> '[t|' { Loc $$ THTypQuote }+> '[d|' { Loc $$ THDecQuote }+> '|]' { Loc $$ THCloseQuote }+> VARQUOTE { Loc $$ THVarQuote } -- 'x+> TYPQUOTE { Loc $$ THTyQuote } -- ''T+> QUASIQUOTE { Loc _ (THQuasiQuote _) }++FreeSect++> '_[' { Loc $$ FSContextOpen }+> ']_' { Loc $$ FSContextClose }+> -- '_[]_' { Loc $$ FSContextOpenClose }++Hsx++> PCDATA { Loc _ (XPCDATA _) }+> '<' { Loc $$ XStdTagOpen }+> '</' { Loc $$ XCloseTagOpen }+> '<%' { Loc $$ XCodeTagOpen }+> '<%>' { Loc $$ XChildTagOpen }+> '>' { Loc $$ XStdTagClose }+> '/>' { Loc $$ XEmptyTagClose }+> '%>' { Loc $$ XCodeTagClose }+> '<[' { Loc $$ XRPatOpen }+> ']>' { Loc $$ XRPatClose }++FFI++> 'foreign' { Loc $$ KW_Foreign }+> 'export' { Loc $$ KW_Export }+> 'safe' { Loc $$ KW_Safe }+> 'unsafe' { Loc $$ KW_Unsafe }+> 'threadsafe' { Loc $$ KW_Threadsafe }+> 'stdcall' { Loc $$ KW_StdCall }+> 'ccall' { Loc $$ KW_CCall }++Reserved Ids++> 'as' { Loc $$ KW_As }+> 'by' { Loc $$ KW_By } -- transform list comprehensions+> 'case' { Loc $$ KW_Case }+> 'class' { Loc $$ KW_Class }+> 'data' { Loc $$ KW_Data }+> 'default' { Loc $$ KW_Default }+> 'deriving' { Loc $$ KW_Deriving }+> 'do' { Loc $$ KW_Do }+> 'else' { Loc $$ KW_Else }+> 'family' { Loc $$ KW_Family } -- indexed type families+> 'forall' { Loc $$ KW_Forall } -- universal/existential qualification+> 'group' { Loc $$ KW_Group } -- transform list comprehensions+> 'hiding' { Loc $$ KW_Hiding }+> 'if' { Loc $$ KW_If }+> 'import' { Loc $$ KW_Import }+> 'in' { Loc $$ KW_In }+> 'infix' { Loc $$ KW_Infix }+> 'infixl' { Loc $$ KW_InfixL }+> 'infixr' { Loc $$ KW_InfixR }+> 'instance' { Loc $$ KW_Instance }+> 'let' { Loc $$ KW_Let }+> 'mdo' { Loc $$ KW_MDo }+> 'module' { Loc $$ KW_Module }+> 'newtype' { Loc $$ KW_NewType }+> 'of' { Loc $$ KW_Of }+> 'proc' { Loc $$ KW_Proc } -- arrows+> 'rec' { Loc $$ KW_Rec } -- arrows+> 'then' { Loc $$ KW_Then }+> 'type' { Loc $$ KW_Type }+> 'using' { Loc $$ KW_Using } -- transform list comprehensions+> 'where' { Loc $$ KW_Where }+> 'qualified' { Loc $$ KW_Qualified }++Pragmas++> '{-# INLINE' { Loc _ (INLINE _) }+> '{-# INLINE_CONLIKE' { Loc $$ INLINE_CONLIKE }+> '{-# SPECIALISE' { Loc $$ SPECIALISE }+> '{-# SPECIALISE_INLINE' { Loc _ (SPECIALISE_INLINE _) }+> '{-# SOURCE' { Loc $$ SOURCE }+> '{-# RULES' { Loc $$ RULES }+> '{-# CORE' { Loc $$ CORE }+> '{-# SCC' { Loc $$ SCC }+> '{-# GENERATED' { Loc $$ GENERATED }+> '{-# DEPRECATED' { Loc $$ DEPRECATED }+> '{-# WARNING' { Loc $$ WARNING }+> '{-# UNPACK' { Loc $$ UNPACK }+> '{-# OPTIONS' { Loc _ (OPTIONS _) }+ '{-# CFILES' { Loc _ (CFILES _) }+ '{-# INCLUDE' { Loc _ (INCLUDE _) }+> '{-# LANGUAGE' { Loc $$ LANGUAGE }+> '{-# ANN' { Loc $$ ANN }+> '#-}' { Loc $$ PragmaEnd }+++> %monad { P }+> %lexer { lexer } { Loc _ EOF }+> %error { parseError }+> %name mparseModule page+> %name mparseExp trueexp+> %name mparsePat pat+> %name mparseDecl topdecl+> %name mparseType truectype+> %name mparseStmt stmt+> %name mparseModules modules+> %partial mfindOptPragmas toppragmas+> %tokentype { Loc Token }+> %expect 6+> %%++-----------------------------------------------------------------------------+Testing multiple modules in one file++> modules :: { [Module L] }+> : toppragmas modules1 { let (os,ss,l) = $1 in map (\x -> x os ss l) $2 }++> modules1 :: { [[ModulePragma L] -> [S] -> L -> Module L] }+> : module modules1 { $1 : $2 }+> | module { [$1] }++-----------------------------------------------------------------------------+HSP Pages++Any HSP-specific parts requiring the XmlSyntax extension enabled will+be governed by the lexing, since all productions require at least one+special lexeme.++TODO: Yuck, this is messy, needs fixing in the AST!++> page :: { Module L }+> : toppragmas topxml {% checkPageModule $2 $1 }+> | toppragmas '<%' module '%>' topxml {% let (os,ss,l) = $1 in checkHybridModule $5 ($3 os ss l) $2 $4 }+> | toppragmas module { let (os,ss,l) = $1 in $2 os ss l }++> topxml :: { PExp L }+> : '<' name attrs mattr '>' children '</' name '>' {% do { n <- checkEqNames $2 $8;+> let { cn = reverse $6;+> as = reverse $3; };+> return $ XTag ($1 <^^> $9 <** [$1,$5,$7,$9]) n as $4 cn } }+> | '<' name attrs mattr '/>' { XETag ($1 <^^> $5 <** [$1,$5]) $2 (reverse $3) $4 }+++> toppragmas :: { ([ModulePragma L],[S],L) }+> : open toppragmasaux close { let (os,ss,ml) = $2 in (os,$1:ss++[$3],$1 <^^> $3) }++> toppragmasaux :: { ([ModulePragma L],[S],Maybe L) }+> : toppragma ';' toppragmasaux { let (os,ss,ml) = $3 in ($1 : os, $2 : ss, Just $ ann $1 <++> nIS $2 <+?> ml) }+> | {- nothing -} { ([],[],Nothing) }++> toppragma :: { ModulePragma L }+> : '{-# LANGUAGE' conids optsemis '#-}' { LanguagePragma ($1 <^^> $4 <** ($1:snd $2 ++ reverse $3 ++ [$4])) (fst $2) }+> | '{-# OPTIONS' optsemis '#-}' { let Loc l (OPTIONS (mc, s)) = $1+> in OptionsPragma (l <^^> $3 <** (l:reverse $2 ++ [$3])) (readTool mc) s }+> | '{-# ANN' annotation '#-}' { AnnModulePragma ($1 <^^> $3 <** [$1,$3]) $2 }+++> conids :: { ([Name L],[S]) }+> : conid ',' conids { ($1 : fst $3, $2 : snd $3) }+> | conid { ([$1],[]) }++-----------------------------------------------------------------------------+Module Header++> module :: { [ModulePragma L] -> [S] -> L -> Module L }+> : optmodulehead body+> { let (is,ds,ss1,inf) = $2+> in \os ss l -> Module (l <++> inf <** (ss ++ ss1)) $1 os is ds }++> optmodulehead :: { Maybe (ModuleHead L) }+> : 'module' modid maybemodwarning maybeexports 'where' { Just $ ModuleHead ($1 <^^> $5 <** [$1,$5]) $2 $3 $4 }+> | {- empty -} { Nothing }++> maybemodwarning :: { Maybe (WarningText L) }+> : '{-# DEPRECATED' STRING '#-}' { let Loc l (StringTok (s,_)) = $2 in Just $ DeprText ($1 <^^> $3 <** [$1,l,$3]) s }+> | '{-# WARNING' STRING '#-}' { let Loc l (StringTok (s,_)) = $2 in Just $ WarnText ($1 <^^> $3 <** [$1,l,$3]) s }+> | {- empty -} { Nothing }++> body :: { ([ImportDecl L],[Decl L],[S],L) }+> : '{' bodyaux '}' { let (is,ds,ss) = $2 in (is,ds,$1:ss ++ [$3], $1 <^^> $3) }+> | open bodyaux close { let (is,ds,ss) = $2 in (is,ds,$1:ss ++ [$3], $1 <^^> $3) }++> bodyaux :: { ([ImportDecl L],[Decl L],[S]) }+> : optsemis impdecls semis topdecls { (reverse (fst $2), fst $4, reverse $1 ++ snd $2 ++ reverse $3 ++ snd $4) }+> | optsemis topdecls { ([], fst $2, reverse $1 ++ snd $2) }+> | optsemis impdecls optsemis { (reverse (fst $2), [], reverse $1 ++ snd $2 ++ reverse $3) }+> | optsemis { ([], [], reverse $1) }++> semis :: { [S] }+> : optsemis ';' { $2 : $1 }++> optsemis :: { [S] }+> : semis { $1 }+> | {- empty -} { [] }++-----------------------------------------------------------------------------+The Export List++> maybeexports :: { Maybe (ExportSpecList L) }+> : exports { Just $1 }+> | {- empty -} { Nothing }++> exports :: { ExportSpecList L }+> : '(' exportlist optcomma ')' { ExportSpecList ($1 <^^> $4 <** ($1:reverse (snd $2) ++ $3 ++ [$4])) (reverse (fst $2)) }+> | '(' optcomma ')' { ExportSpecList ($1 <^^> $3 <** ($1:$2++[$3])) [] }++> optcomma :: { [S] }+> : ',' { [$1] }+> | {- empty -} { [ ] }++> exportlist :: { ([ExportSpec L],[S]) }+> : exportlist ',' export { ($3 : fst $1, $2 : snd $1) }+> | export { ([$1],[]) }++> export :: { ExportSpec L }+> : qvar { EVar (ann $1) $1 }+> | qtyconorcls { EAbs (ann $1) $1 }+> | qtyconorcls '(' '..' ')' { EThingAll (ann $1 <++> nIS $4 <** [$2,$3,$4]) $1 }+> | qtyconorcls '(' ')' { EThingWith (ann $1 <++> nIS $3 <** [$2,$3]) $1 [] }+> | qtyconorcls '(' cnames ')' { EThingWith (ann $1 <++> nIS $4 <** ($2:reverse (snd $3) ++ [$4])) $1 (reverse (fst $3)) }+> | 'module' modid { EModuleContents (nIS $1 <++> ann $2 <** [$1]) $2 }++-----------------------------------------------------------------------------+Import Declarations++> impdecls :: { ([ImportDecl L],[S]) }+> : impdecls semis impdecl { ($3 : fst $1, snd $1 ++ reverse $2) }+> | impdecl { ([$1],[]) }++> impdecl :: { ImportDecl L }+> : 'import' optsrc optqualified maybepkg modid maybeas maybeimpspec+> { let { (mmn,ss,ml) = $6 ;+> l = nIS $1 <++> ann $5 <+?> ml <+?> (fmap ann) $7 <** ($1:snd $2 ++ snd $3 ++ snd $4 ++ ss)}+> in ImportDecl l $5 (fst $3) (fst $2) (fst $4) mmn $7 }++> optsrc :: { (Bool,[S]) }+> : '{-# SOURCE' '#-}' { (True,[$1,$2]) }+> | {- empty -} { (False,[]) }++> optqualified :: { (Bool,[S]) }+> : 'qualified' { (True,[$1]) }+> | {- empty -} { (False, []) }++Requires the PackageImports extension enabled.+> maybepkg :: { (Maybe String,[S]) }+> : STRING {% do { checkEnabled PackageImports ;+> let { Loc l (StringTok (s,_)) = $1 } ;+> return $ (Just s,[l]) } }+> | {- empty -} { (Nothing,[]) }++> maybeas :: { (Maybe (ModuleName L),[S],Maybe L) }+> : 'as' modid { (Just $2,[$1],Just (nIS $1 <++> ann $2)) }+> | {- empty -} { (Nothing,[],Nothing) }+++> maybeimpspec :: { Maybe (ImportSpecList L) }+> : impspec { Just $1 }+> | {- empty -} { Nothing }++> impspec :: { ImportSpecList L }+> : opthiding '(' importlist optcomma ')' { let {(b,ml,s) = $1 ;+> l = (ml <?+> ($2 <^^> $5)) <** (s ++ $2:reverse (snd $3) ++ $4 ++ [$5])}+> in ImportSpecList l b (reverse (fst $3)) }+> | opthiding '(' optcomma ')' { let {(b,ml,s) = $1 ; l = (ml <?+> ($2 <^^> $4)) <** (s ++ $2:$3 ++ [$4])}+> in ImportSpecList l b [] }++> opthiding :: { (Bool, Maybe L,[S]) }+> : 'hiding' { (True,Just (nIS $1),[$1]) }+> | {- empty -} { (False,Nothing,[]) }++> importlist :: { ([ImportSpec L],[S]) }+> : importlist ',' importspec { ($3 : fst $1, $2 : snd $1) }+> | importspec { ([$1],[]) }++> importspec :: { ImportSpec L }+> : var { IVar (ann $1) $1 }+> | tyconorcls { IAbs (ann $1) $1 }+> | tyconorcls '(' '..' ')' { IThingAll (ann $1 <++> nIS $4 <** [$2,$3,$4]) $1 }+> | tyconorcls '(' ')' { IThingWith (ann $1 <++> nIS $3 <** [$2,$3]) $1 [] }+> | tyconorcls '(' cnames ')' { IThingWith (ann $1 <++> nIS $4 <** ($2:reverse (snd $3) ++ [$4])) $1 (reverse (fst $3)) }++> cnames :: { ([CName L],[S]) }+> : cnames ',' cname { ($3 : fst $1, $2 : snd $1) }+> | cname { ([$1],[]) }++> cname :: { CName L }+> : var { VarName (ann $1) $1 }+> | con { ConName (ann $1) $1 }++-----------------------------------------------------------------------------+Fixity Declarations++> fixdecl :: { Decl L }+> : infix prec ops { let (ops,ss,l) = $3+> in InfixDecl (ann $1 <++> l <** (snd $2 ++ reverse ss)) $1 (fst $2) (reverse ops) }++> prec :: { (Maybe Int, [S]) }+> : {- empty -} { (Nothing, []) }+> | INT {% let Loc l (IntTok (i,_)) = $1 in checkPrec i >>= \i -> return (Just i, [l]) }++> infix :: { Assoc L }+> : 'infix' { AssocNone $ nIS $1 }+> | 'infixl' { AssocLeft $ nIS $1 }+> | 'infixr' { AssocRight $ nIS $1 }++> ops :: { ([Op L],[S],L) }+> : ops ',' op { let (ops,ss,l) = $1 in ($3 : ops, $2 : ss, l <++> ann $3) }+> | op { ([$1],[],ann $1) }++-----------------------------------------------------------------------------+Top-Level Declarations++Note: The report allows topdecls to be empty. This would result in another+shift/reduce-conflict, so we don't handle this case here, but in bodyaux.++> topdecls :: { ([Decl L],[S]) }+> : topdecls1 optsemis {% checkRevDecls (fst $1) >>= \ds -> return (ds, snd $1 ++ reverse $2) }++> topdecls1 :: { ([Decl L],[S]) }+> : topdecls1 semis topdecl { ($3 : fst $1, snd $1 ++ reverse $2) }+> | topdecl { ([$1],[]) }++> topdecl :: { Decl L }+> : 'type' dtype '=' truectype+> {% do { dh <- checkSimpleType $2;+> let {l = nIS $1 <++> ann $4 <** [$1,$3]};+> return (TypeDecl l dh $4) } }++Requires the TypeFamilies extension enabled, but the lexer will handle+that through the 'family' keyword.+> | 'type' 'family' type optkind+> {% do { dh <- checkSimpleType $3;+> let {l = nIS $1 <++> ann $3 <+?> (fmap ann) (fst $4) <** ($1:$2:snd $4)};+> return (TypeFamDecl l dh (fst $4)) } }++Here there is no special keyword so we must do the check.+> | 'type' 'instance' truedtype '=' truectype+> {% do { -- no checkSimpleType $4 since dtype may contain type patterns+> checkEnabled TypeFamilies ;+> let {l = nIS $1 <++> ann $5 <** [$1,$2,$4]};+> return (TypeInsDecl l $3 $5) } }+> | data_or_newtype ctype constrs0 deriving+> {% do { (cs,dh) <- checkDataHeader $2;+> let { (qds,ss,minf) = $3;+> l = $1 <> $2 <+?> minf <+?> fmap ann $4 <** ss};+> checkDataOrNew $1 qds;+> return (DataDecl l $1 cs dh (reverse qds) $4) } }++Requires the GADTs extension enabled, handled in gadtlist.+> | data_or_newtype ctype optkind gadtlist deriving+> {% do { (cs,dh) <- checkDataHeader $2;+> let { (gs,ss,minf) = $4;+> l = ann $1 <+?> minf <+?> fmap ann $5 <** (snd $3 ++ ss)};+> checkDataOrNewG $1 gs;+> case (gs, fst $3) of+> ([], Nothing) -> return (DataDecl l $1 cs dh [] $5)+> _ -> checkEnabled GADTs >> return (GDataDecl l $1 cs dh (fst $3) (reverse gs) $5) } }++Same as above, lexer will handle it through the 'family' keyword.+> | 'data' 'family' ctype optkind+> {% do { (cs,dh) <- checkDataHeader $3;+> let {l = nIS $1 <++> ann $3 <+?> (fmap ann) (fst $4) <** ($1:$2:snd $4)};+> return (DataFamDecl l cs dh (fst $4)) } }++Here we must check for TypeFamilies.+> | data_or_newtype 'instance' truectype constrs0 deriving+> {% do { -- (cs,c,t) <- checkDataHeader $4;+> checkEnabled TypeFamilies ;+> let { (qds,ss,minf) = $4 ;+> l = $1 <> $3 <+?> minf <+?> fmap ann $5 <** $2:ss };+> checkDataOrNew $1 qds;+> return (DataInsDecl l $1 $3 (reverse qds) $5) } }++This style requires both TypeFamilies and GADTs, the latter is handled in gadtlist.+> | data_or_newtype 'instance' truectype optkind gadtlist deriving+> {% do { -- (cs,c,t) <- checkDataHeader $4;+> checkEnabled TypeFamilies ;+> let {(gs,ss,minf) = $5;+> l = ann $1 <+?> minf <+?> fmap ann $6 <** ($2:snd $4 ++ ss)};+> checkDataOrNewG $1 gs;+> return (GDataInsDecl l $1 $3 (fst $4) (reverse gs) $6) } }+> | 'class' ctype fds optcbody+> {% do { (cs,dh) <- checkClassHeader $2;+> let {(fds,ss1,minf1) = $3;(mcs,ss2,minf2) = $4} ;+> let { l = nIS $1 <++> ann $2 <+?> minf1 <+?> minf2 <** ($1:ss1 ++ ss2)} ;+> return (ClassDecl l cs dh fds mcs) } }+> | 'instance' ctype optvaldefs+> {% do { (cs,ih) <- checkInstHeader $2;+> let {(mis,ss,minf) = $3};+> return (InstDecl (nIS $1 <++> ann $2 <+?> minf <** ($1:ss)) cs ih mis) } }++Requires the StandaloneDeriving extension enabled.+> | 'deriving' 'instance' ctype+> {% do { checkEnabled StandaloneDeriving ;+> (cs, ih) <- checkInstHeader $3;+> let {l = nIS $1 <++> ann $3 <** [$1,$2]};+> return (DerivDecl l cs ih) } }+> | 'default' '(' typelist ')'+> { DefaultDecl ($1 <^^> $4 <** ($1:$2 : snd $3 ++ [$4])) (fst $3) }++Requires the TemplateHaskell extension, but the lexer will handle that+through the '$(' lexeme.+CHANGE: Arbitrary top-level expressions are considered implicit splices+> | exp0 {% checkEnabled TemplateHaskell >> checkExpr $1 >>= \e -> return (SpliceDecl (ann e) e) }++ | '$(' trueexp ')' { let l = $1 <^^> $3 <** [$1,$3] in SpliceDecl l $ ParenSplice l $2 }++These require the ForeignFunctionInterface extension, handled by the+lexer through the 'foreign' (and 'export') keyword.+> | 'foreign' 'import' callconv safety fspec+> { let (s,n,t,ss) = $5 in ForImp (nIS $1 <++> ann t <** ($1:$2:ss)) $3 $4 s n t }+> | 'foreign' 'export' callconv fspec+> { let (s,n,t,ss) = $4 in ForExp (nIS $1 <++> ann t <** ($1:$2:ss)) $3 s n t }++> | '{-# RULES' rules '#-}' { RulePragmaDecl ($1 <^^> $3 <** [$1,$3]) $ reverse $2 }+> | '{-# DEPRECATED' warndeprs '#-}' { DeprPragmaDecl ($1 <^^> $3 <** ($1:snd $2++[$3])) $ reverse (fst $2) }+> | '{-# WARNING' warndeprs '#-}' { WarnPragmaDecl ($1 <^^> $3 <** ($1:snd $2++[$3])) $ reverse (fst $2) }+> | '{-# ANN' annotation '#-}' { AnnPragma ($1 <^^> $3 <** [$1,$3]) $2 }+> | decl { $1 }++> data_or_newtype :: { DataOrNew L }+> : 'data' { DataType $ nIS $1 }+> | 'newtype' { NewType $ nIS $1 }++> typelist :: { ([Type L],[S]) }+> : types {% do { ts <- mapM checkType (fst $1);+> return $ (reverse ts, reverse (snd $1)) } }+> | truetype { ([$1],[]) }+> | {- empty -} { ([],[]) }++> decls :: { ([Decl L],[S]) }+> : optsemis decls1 optsemis {% checkRevDecls (fst $2) >>= \ds -> return (ds, reverse $1 ++ snd $2 ++ reverse $3) }+> | optsemis { ([],reverse $1) }++> decls1 :: { ([Decl L],[S]) }+> : decls1 semis decl { ($3 : fst $1, snd $1 ++ reverse $2) }+> | decl { ([$1],[]) }++> decl :: { Decl L }+> : signdecl { $1 }+> | fixdecl { $1 }+> | valdef { $1 }++> decllist :: { Binds L }+> : '{' decls '}' { BDecls ($1 <^^> $3 <** ($1:snd $2++[$3])) (fst $2) }+> | open decls close { BDecls ($1 <^^> $3 <** ($1:snd $2++[$3])) (fst $2) }++> signdecl :: { Decl L }+> : exp0b '::' truectype {% do { v <- checkSigVar $1;+> return $ TypeSig ($1 <> $3 <** [$2]) [v] $3 } }+> | exp0b ',' vars '::' truectype {% do { v <- checkSigVar $1;+> let {(vs,ss,_) = $3 ; l = $1 <> $5 <** ($2 : reverse ss ++ [$4]) } ;+> return $ TypeSig l (v : reverse vs) $5 } }+> | specinldecl { $1 }++> specinldecl :: { Decl L }+> : '{-# INLINE' activation qvar '#-}' { let Loc l (INLINE s) = $1 in InlineSig (l <^^> $4 <** [l,$4]) s $2 $3 }+> | '{-# INLINE_CONLIKE' activation qvar '#-}' { InlineConlikeSig ($1 <^^> $4 <** [$1,$4]) $2 $3 }+> | '{-# SPECIALISE' qvar '::' sigtypes '#-}' { SpecSig ($1 <^^> $5 <** ($1:$3 : snd $4 ++ [$5])) $2 (fst $4) }+> | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes '#-}'+> { let Loc l (SPECIALISE_INLINE s) = $1+> in SpecInlineSig (l <^^> $6 <** (l:$4:snd $5++[$6])) s $2 $3 (fst $5) }+> | '{-# SPECIALISE' 'instance' ctype '#-}' {% do { (cs,ih) <- checkInstHeader $3;+> let {l = $1 <^^> $4 <** [$1,$2,$4]};+> return $ InstSig l cs ih } }++> sigtypes :: { ([Type L],[S]) }+> : sigtype { ([$1],[]) }+> | sigtype ',' sigtypes { ($1 : fst $3, $2 : snd $3) }++> sigtype :: { Type L }+> : ctype {% checkType $ mkTyForall (ann $1) Nothing Nothing $1 }++Binding can be either of implicit parameters, or it can be a normal sequence+of declarations. The two kinds cannot be mixed within the same block of+binding.++> binds :: { Binds L }+> : decllist { $1 }+> | '{' ipbinds '}' { IPBinds ($1 <^^> $3 <** snd $2) (fst $2) }+> | open ipbinds close { IPBinds ($1 <^^> $3 <** snd $2) (fst $2) }++ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var+instead of qvar, we get another shift/reduce-conflict. Consider the+following programs:++ { (+) :: ... } only var+ { (+) x y = ... } could (incorrectly) be qvar++We re-use expressions for patterns, so a qvar would be allowed in patterns+instead of a var only (which would be correct). But deciding what the + is,+would require more lookahead. So let's check for ourselves...++> vars :: { ([Name L],[S],L) }+> : vars ',' var { let (ns,ss,l) = $1 in ($3 : ns, $2 : ss, l <++> ann $3) }+> | qvar {% do { n <- checkUnQual $1;+> return ([n],[],ann n) } }++-----------------------------------------------------------------------------+FFI++These will only be called on in the presence of a 'foreign' keyword,+so no need to check for extensions.++> callconv :: { CallConv L }+> : 'stdcall' { StdCall (nIS $1) }+> | 'ccall' { CCall (nIS $1) }++> safety :: { Maybe (Safety L) }+> : 'safe' { Just $ PlaySafe (nIS $1) False }+> | 'unsafe' { Just $ PlayRisky (nIS $1) }+> | 'threadsafe' { Just $ PlaySafe (nIS $1) True }+> | {- empty -} { Nothing }++> fspec :: { (Maybe String, Name L, Type L, [S]) }+> : STRING var_no_safety '::' truedtype { let Loc l (StringTok (s,_)) = $1 in (Just s, $2, $4, [l,$3]) }+> | var_no_safety '::' truedtype { (Nothing, $1, $3, [$2]) }++-----------------------------------------------------------------------------+Pragmas++> rules :: { [Rule L] }+> : rules ';'rule { $3 : $1 }+> | rules ';' { $1 }+> | rule { [$1] }+> | {- empty -} { [] }++> rule :: { Rule L }+> : STRING activation ruleforall exp0 '=' trueexp {% do { let {Loc l (StringTok (s,_)) = $1};+> e <- checkRuleExpr $4;+> return $ Rule (nIS l <++> ann $6 <** l:snd $3 ++ [$5]) s $2 (fst $3) e $6 } }++> activation :: { Maybe (Activation L) }+> : {- empty -} { Nothing }+> | '[' INT ']' { let Loc l (IntTok (i,_)) = $2 in Just $ ActiveFrom ($1 <^^> $3 <** [$1,l,$3]) (fromInteger i) }+> | '[' '~' INT ']' { let Loc l (IntTok (i,_)) = $3 in Just $ ActiveUntil ($1 <^^> $4 <** [$1,$2,l,$4]) (fromInteger i) }++> ruleforall :: { (Maybe [RuleVar L],[S]) }+> : {- empty -} { (Nothing,[]) }+> | 'forall' rulevars '.' { (Just $2,[$1,$3]) }++> rulevars :: { [RuleVar L] }+> : rulevar { [$1] }+> | rulevar rulevars { $1 : $2 }++> rulevar :: { RuleVar L }+> : varid { RuleVar (ann $1) $1 }+> | '(' varid '::' truectype ')' { TypedRuleVar ($1 <^^> $5 <** [$1,$3,$5]) $2 $4 }++> warndeprs :: { ([([Name L],String)],[S]) }+> : warndeprs ';' warndepr { (fst $3 : fst $1, snd $1 ++ ($2:snd $3)) }+> | warndeprs ';' { (fst $1, snd $1 ++ [$2]) }+> | warndepr { ([fst $1],snd $1) }+> | {- empty -} { ([],[]) }++> warndepr :: { (([Name L], String),[S]) }+> : namevars STRING { let Loc l (StringTok (s,_)) = $2 in ((fst $1,s),snd $1 ++ [l]) }++> namevars :: { ([Name L],[S]) }+> : namevar { ([$1],[]) }+> | namevar ',' namevars { ($1 : fst $3, $2 : snd $3) }++> namevar :: { Name L }+> : con { $1 }+> | var { $1 }++> annotation :: { Annotation L }+> : 'type' conid aexp {% checkExpr $3 >>= \e -> return (TypeAnn (nIS $1 <++> ann e <** [$1]) $2 e) }+> | 'module' aexp {% checkExpr $2 >>= \e -> return (ModuleAnn (nIS $1 <++> ann e <** [$1]) e) }+> | namevar aexp {% checkExpr $2 >>= \e -> return (Ann ($1 <> e) $1 e) }++-----------------------------------------------------------------------------+Types++Type equality contraints need the TypeFamilies extension.++> truedtype :: { Type L }+> : dtype {% checkType $1 }++> dtype :: { PType L }+> : btype { $1 }+> | btype qtyconop dtype { TyInfix ($1 <> $3) $1 $2 $3 }+> | btype qtyvarop dtype { TyInfix ($1 <> $3) $1 $2 $3 } -- FIXME+> | btype '->' ctype { TyFun ($1 <> $3 <** [$2]) $1 $3 }+> | btype '~' btype {% do { checkEnabled TypeFamilies ;+> let {l = $1 <> $3 <** [$2]};+> return $ TyPred l $ EqualP l $1 $3 } }++Implicit parameters can occur in normal types, as well as in contexts.++> truetype :: { Type L }+> : type {% checkType $1 }++> type :: { PType L }+> : ivar '::' dtype { let l = ($1 <> $3 <** [$2]) in TyPred l $ IParam l $1 $3 }+> | dtype { $1 }++> truebtype :: { Type L }+> : btype {% checkType $1 }++> btype :: { PType L }+> : btype atype { TyApp ($1 <> $2) $1 $2 }+> | atype { $1 }++UnboxedTuples requires the extension, but that will be handled through+the (# and #) lexemes. Kinds will be handled at the kind rule.++> trueatype :: { Type L }+> : atype {% checkType $1 }++> atype :: { PType L }+> : gtycon { TyCon (ann $1) $1 }+> | tyvar { TyVar (ann $1) $1 }+> | '(' types ')' { TyTuple ($1 <^^> $3 <** ($1:reverse ($3:snd $2))) Boxed (reverse (fst $2)) }+> | '(#' types1 '#)' { TyTuple ($1 <^^> $3 <** ($1:reverse ($3:snd $2))) Unboxed (reverse (fst $2)) }+> | '[' type ']' { TyList ($1 <^^> $3 <** [$1,$3]) $2 }+> | '(' ctype ')' { TyParen ($1 <^^> $3 <** [$1,$3]) $2 }+> | '(' ctype '::' kind ')' { TyKind ($1 <^^> $5 <** [$1,$3,$5]) $2 $4 }++> gtycon :: { QName L }+> : otycon { $1 }+> | '(' ')' { unit_tycon_name ($1 <^^> $2 <** [$1,$2]) }+> | '(' '->' ')' { fun_tycon_name ($1 <^^> $3 <** [$1,$2,$3]) }+> | '[' ']' { list_tycon_name ($1 <^^> $2 <** [$1,$2]) }+> | '(' commas ')' { tuple_tycon_name ($1 <^^> $3 <** ($1:reverse $2 ++ [$3])) Boxed (length $2) }+> | '(#' '#)' { unboxed_singleton_tycon_name ($1 <^^> $2 <** [$1,$2]) }+> | '(#' commas '#)' { tuple_tycon_name ($1 <^^> $3 <** ($1:reverse $2 ++ [$3])) Unboxed (length $2) }++> otycon :: { QName L }+> : qconid { $1 }+> | '(' gconsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }+> | '(' qvarsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++These are for infix types++> qtyconop :: { QName L }+> : qconop { $1 }+++(Slightly edited) Comment from GHC's hsparser.y:+"context => type" vs "type" is a problem, because you can't distinguish between++ foo :: (Baz a, Baz a)+ bar :: (Baz a, Baz a) => [a] -> [a] -> [a]++with one token of lookahead. The HACK is to parse the context as a btype+(more specifically as a tuple type), then check that it has the right form+C a, or (C1 a, C2 b, ... Cn z) and convert it into a context. Blaach!++Forall-quantified types require some extension to enable them, which+is any of the keyword-enabling ones, except ExistentialQuantification.++> truectype :: { Type L }+> : ctype {% checkType $1 }++> ctype :: { PType L }+> : 'forall' ktyvars '.' ctype { TyForall (nIS $1 <++> ann $4 <** [$1,$3]) (Just (reverse (fst $2))) Nothing $4 }+> | context ctype { TyForall ($1 <> $2) Nothing (Just $1) $2 }+> | type { $1 }++Equality constraints require the TypeFamilies extension.++> context :: { PContext L }+> : btype '=>' {% checkPContext $ (amap (\l -> l <++> nIS $2 <** (srcInfoPoints l ++ [$2]))) $1 }+> | btype '~' btype '=>' {% do { checkEnabled TypeFamilies;+> let {l = $1 <> $3 <** [$2,$4]};+> checkPContext (TyPred l $ EqualP l $1 $3) } }++> types :: { ([PType L],[S]) }+> : types1 ',' ctype { ($3 : fst $1, $2 : snd $1) }++> types1 :: { ([PType L],[S]) }+> : ctype { ([$1],[]) }+> | types1 ',' ctype { ($3 : fst $1, $2 : snd $1) }++> ktyvars :: { ([TyVarBind L],Maybe L) }+> : ktyvars ktyvar { ($2 : fst $1, Just (snd $1 <?+> ann $2)) }+> | {- empty -} { ([],Nothing) }++> ktyvar :: { TyVarBind L }+> : tyvar { UnkindedVar (ann $1) $1 }+> | '(' tyvar '::' kind ')' { KindedVar ($1 <^^> $5 <** [$1,$3,$5]) $2 $4 }++> tyvars :: { ([Name L],Maybe L) }+> : tyvars tyvar { ($2 : fst $1, Just (snd $1 <?+> ann $2)) }+> | {- empty -} { ([], Nothing) }++> tyvars1 :: { ([Name L],L) }+> : tyvars tyvar { ($2 : fst $1, snd $1 <?+> ann $2) }+++-----------------------------------------------------------------------------+Functional Dependencies++These require the FunctionalDependencies extension to be enabled.++> fds :: { ([FunDep L],[S],Maybe L) }+> : {- empty -} { ([],[], Nothing) }+> | '|' fds1 {% do { checkEnabled FunctionalDependencies ;+> let {(fds,ss,l) = $2} ;+> return (reverse fds, $1 : reverse ss, Just (nIS $1 <++> l)) } }++> fds1 :: { ([FunDep L],[S],L) }+> : fds1 ',' fd { let (fds,ss,l) = $1 in ($3 : fds, $2 : ss, l <++> ann $3) }+> | fd { ([$1],[],ann $1) }++> fd :: { FunDep L }+> : tyvars1 '->' tyvars1 { FunDep (snd $1 <++> snd $3 <** [$2]) (reverse (fst $1)) (reverse (fst $3)) }++-----------------------------------------------------------------------------+Datatype declarations++GADTs - require the GADTs extension enabled, but we handle that at the calling site.++ gadtlist :: { ([GadtDecl L],[S],L) }+ : gadtlist1 {% >> return $1 }++> gadtlist :: { ([GadtDecl L],[S],Maybe L) }+> : 'where' '{' gadtconstrs1 '}' {% return (fst $3, $1 : $2 : snd $3 ++ [$4], Just $ $1 <^^> $4) }+> | 'where' open gadtconstrs1 close {% return (fst $3, $1 : $2 : snd $3 ++ [$4], Just $ $1 <^^> $4) }+> | {- empty -} {% checkEnabled EmptyDataDecls >> return ([],[],Nothing) }++> gadtconstrs1 :: { ([GadtDecl L],[S]) }+> : optsemis gadtconstrs optsemis { (fst $2, reverse $1 ++ snd $2 ++ reverse $3) }++> gadtconstrs :: { ([GadtDecl L],[S]) }+> : gadtconstrs semis gadtconstr { ($3 : fst $1, snd $1 ++ reverse $2) }+> | gadtconstr { ([$1],[]) }++> gadtconstr :: { GadtDecl L }+> : qcon '::' truectype {% do { c <- checkUnQual $1;+> return $ GadtDecl ($1 <> $3 <** [$2]) c $3 } }++To allow the empty case we need the EmptyDataDecls extension.+> constrs0 :: { ([QualConDecl L],[S],Maybe L) }+ : {- empty -} {% checkEnabled EmptyDataDecls >> return ([],[],Nothing) }+> : '=' constrs { let (ds,ss,l) = $2 in (ds, $1 : reverse ss, Just $ nIS $1 <++> l) }++> constrs :: { ([QualConDecl L],[S],L) }+> : constrs '|' constr { let (ds,ss,l) = $1 in ($3 : ds, $2 : ss, l <++> ann $3) }+> | constr { ([$1],[],ann $1) }++> constr :: { QualConDecl L }+> : forall context constr1 {% do { checkEnabled ExistentialQuantification ;+> ctxt <- checkContext (Just $2) ;+> let {(mtvs,ss,ml) = $1} ;+> return $ QualConDecl (ml <?+> ann $3 <** ss) mtvs ctxt $3 } }+> | forall constr1 { let (mtvs, ss, ml) = $1 in QualConDecl (ml <?+> ann $2 <** ss) mtvs Nothing $2 }++> forall :: { (Maybe [TyVarBind L], [S], Maybe L) }+> : 'forall' ktyvars '.' {% checkEnabled ExistentialQuantification >> return (Just (fst $2), [$1,$3], Just $ $1 <^^> $3) }+> | {- empty -} { (Nothing, [], Nothing) }++To avoid conflicts when introducing type operators, we need to parse record constructors+as qcon and then check separately that they are truly unqualified.++> constr1 :: { ConDecl L }+> : scontype { let (n,ts,l) = $1 in ConDecl l n ts }+> | sbtype conop sbtype { InfixConDecl ($1 <> $3) $1 $2 $3 }+> | qcon '{' '}' {% do { c <- checkUnQual $1; return $ RecDecl (ann $1 <++> nIS $3 <** [$2,$3]) c [] } }+> | qcon '{' fielddecls '}' {% do { c <- checkUnQual $1;+> return $ RecDecl (ann $1 <++> nIS $4 <** ($2:reverse (snd $3) ++ [$4])) c (reverse (fst $3)) } }++> scontype :: { (Name L, [BangType L], L) }+> : btype {% do { (c,ts) <- splitTyConApp $1;+> return (c,map (\t -> UnBangedTy (ann t) t) ts,ann $1) } }+> | scontype1 { $1 }++> scontype1 :: { (Name L, [BangType L],L) }+> : btype '!' trueatype {% do { (c,ts) <- splitTyConApp $1;+> return (c,map (\t -> UnBangedTy (ann t) t) ts+++> [BangedTy (nIS $2 <++> ann $3 <** [$2]) $3], $1 <> $3) } }+> | btype '{-# UNPACK' '#-}' '!' trueatype {% do { (c,ts) <- splitTyConApp $1;+> return (c,map (\t -> UnBangedTy (ann t) t) ts+++> [UnpackedTy (nIS $2 <++> ann $5 <** [$2,$3,$4]) $5], $1 <> $5) } }+> | scontype1 satype { let (n,ts,l) = $1 in (n, ts ++ [$2],l <++> ann $2) }++> satype :: { BangType L }+> : trueatype { UnBangedTy (ann $1) $1 }+> | '!' trueatype { BangedTy (nIS $1 <++> ann $2 <** [$1]) $2 }+> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy (nIS $1 <++> ann $4 <** [$1,$2,$3]) $4 }++> sbtype :: { BangType L }+> : truebtype { UnBangedTy (ann $1) $1 }+> | '!' trueatype { BangedTy (nIS $1 <++> ann $2 <** [$1]) $2 }+> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy (nIS $1 <++> ann $4 <** [$1,$2,$3]) $4 }++> fielddecls :: { ([FieldDecl L],[S]) }+> : fielddecls ',' fielddecl { ($3 : fst $1, $2 : snd $1) }+> | fielddecl { ([$1],[]) }++> fielddecl :: { FieldDecl L }+> : vars '::' stype { let (ns,ss,l) = $1 in FieldDecl (l <++> ann $3 <** (reverse ss ++ [$2])) (reverse ns) $3 }++> stype :: { BangType L }+> : truectype { UnBangedTy (ann $1) $1 }+> | '!' trueatype { BangedTy (nIS $1 <++> ann $2 <** [$1]) $2 }+> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy (nIS $1 <++> ann $4 <** [$1,$2,$3]) $4 }++> deriving :: { Maybe (Deriving L) }+> : {- empty -} { Nothing }+> | 'deriving' qtycls1 { let l = nIS $1 <++> ann $2 <** [$1] in Just $ Deriving l [IHead (ann $2) $2 []] }+> | 'deriving' '(' ')' { Just $ Deriving ($1 <^^> $3 <** [$1,$2,$3]) [] }+> | 'deriving' '(' dclasses ')' { Just $ Deriving ($1 <^^> $4 <** $1:$2: reverse (snd $3) ++ [$4]) (reverse (fst $3)) }++> dclasses :: { ([InstHead L],[S]) }+> : types1 {% checkDeriving (fst $1) >>= \ds -> return (ds, snd $1) }++> qtycls1 :: { QName L }+> : qconid { $1 }+++-----------------------------------------------------------------------------+Kinds++> kind :: { Kind L }+> : kind1 {% checkEnabled KindSignatures >> return $1 }++> kind1 :: { Kind L }+> : akind { $1 }+> | akind '->' kind1 { KindFn ($1 <> $3 <** [$2]) $1 $3 }++> akind :: { Kind L }+> : '*' { KindStar (nIS $1) }+> | '!' { KindBang (nIS $1) }+> | '(' kind1 ')' { KindParen ($1 <^^> $3 <** [$1,$3]) $2 }++> optkind :: { (Maybe (Kind L), [S]) }+> : {-empty-} { (Nothing,[]) }+> | '::' kind { (Just $2,[$1]) }+-----------------------------------------------------------------------------+Class declarations++TODO: Lots of stuff to pass around here.++No implicit parameters in the where clause of a class declaration.+> optcbody :: { (Maybe [ClassDecl L],[S],Maybe L) }+> : 'where' '{' cldecls '}' {% checkClassBody (fst $3) >>= \vs -> return (Just vs, $1:$2: snd $3 ++ [$4], Just ($1 <^^> $4)) }+> | 'where' open cldecls close {% checkClassBody (fst $3) >>= \vs -> return (Just vs, $1:$2: snd $3 ++ [$4], Just ($1 <^^> $4)) }+> | {- empty -} { (Nothing,[],Nothing) }++> cldecls :: { ([ClassDecl L],[S]) }+> : optsemis cldecls1 optsemis {% checkRevClsDecls (fst $2) >>= \cs -> return (cs, reverse $1 ++ snd $2 ++ reverse $3) }+> | optsemis { ([],reverse $1) }++> cldecls1 :: { ([ClassDecl L],[S]) }+> : cldecls1 semis cldecl { ($3 : fst $1, snd $1 ++ reverse $2) }+> | cldecl { ([$1],[]) }++Associated types require the TypeFamilies extension.++> cldecl :: { ClassDecl L }+> : decl { ClsDecl (ann $1) $1 }+> | atdecl {% checkEnabled TypeFamilies >> return $1 }++> atdecl :: { ClassDecl L }+> : 'type' type optkind+> {% do { dh <- checkSimpleType $2;+> return (ClsTyFam (nIS $1 <++> ann $2 <+?> (fmap ann) (fst $3) <** $1:snd $3) dh (fst $3)) } }+> | 'type' truedtype '=' truectype+> { ClsTyDef (nIS $1 <++> ann $4 <** [$1,$3]) $2 $4 }+> | 'data' ctype optkind+> {% do { (cs,dh) <- checkDataHeader $2;+> return (ClsDataFam (nIS $1 <++> ann $2 <+?> (fmap ann) (fst $3) <** $1:snd $3) cs dh (fst $3)) } }++-----------------------------------------------------------------------------+Instance declarations++> optvaldefs :: { (Maybe [InstDecl L],[S],Maybe L) }+> : 'where' '{' valdefs '}' {% checkInstBody (fst $3) >>= \vs -> return (Just vs, $1:$2: snd $3 ++ [$4], Just ($1 <^^> $4)) }+> | 'where' open valdefs close {% checkInstBody (fst $3) >>= \vs -> return (Just vs, $1:$2: snd $3 ++ [$4], Just ($1 <^^> $4)) }+> | {- empty -} { (Nothing, [], Nothing) }++> valdefs :: { ([InstDecl L],[S]) }+> : optsemis valdefs1 optsemis {% checkRevInstDecls (fst $2) >>= \is -> return (is, reverse $1 ++ snd $2 ++ reverse $3) }+> | optsemis { ([],reverse $1) }++> valdefs1 :: { ([InstDecl L],[S]) }+> : valdefs1 semis insvaldef { ($3 : fst $1, snd $1 ++ reverse $2) }+> | insvaldef { ([$1],[]) }++Associated types require the TypeFamilies extension enabled.++> insvaldef :: { InstDecl L }+> : valdef { InsDecl (ann $1) $1 }+> | atinst {% checkEnabled TypeFamilies >> return $1 }+> | specinldecl { InsDecl (ann $1) $1 }++ inlinst :: { InstDecl L }+ : '{-# INLINE' activation qvar '#-}' { let Loc l (INLINE s) = $1 in InsInline (l <^^> $4 <** [l,$4]) s $2 $3 }++> atinst :: { InstDecl L }+> : 'type' truedtype '=' truectype+> {% do { -- no checkSimpleType $4 since dtype may contain type patterns+> return (InsType (nIS $1 <++> ann $4 <** [$1,$3]) $2 $4) } }+> | data_or_newtype truectype constrs0 deriving+> {% do { -- (cs,c,t) <- checkDataHeader $4;+> let {(ds,ss,minf) = $3};+> checkDataOrNew $1 ds;+> return (InsData ($1 <> $2 <+?> minf <+?> fmap ann $4 <** ss ) $1 $2 (reverse ds) $4) } }+> | data_or_newtype truectype optkind gadtlist deriving+> {% do { -- (cs,c,t) <- checkDataHeader $4;+> let { (gs,ss,minf) = $4 } ;+> checkDataOrNewG $1 gs;+> return $ InsGData (ann $1 <+?> minf <+?> fmap ann $5 <** (snd $3 ++ ss)) $1 $2 (fst $3) (reverse gs) $5 } }++-----------------------------------------------------------------------------+Value definitions++> valdef :: { Decl L }+> : exp0b optsig rhs optwhere {% checkValDef (($1 <> $3 <+?> (fmap ann) (fst $4)) <** (snd $2 ++ snd $4)) $1 (fst $2) $3 (fst $4) }+> | '!' aexp rhs optwhere {% do { checkEnabled BangPatterns ;+> let { l = nIS $1 <++> ann $2 <** [$1] };+> p <- checkPattern (BangPat l $2);+> return $ PatBind (p <> $3 <+?> (fmap ann) (fst $4) <** snd $4)+> p Nothing $3 (fst $4) } }++May bind implicit parameters+> optwhere :: { (Maybe (Binds L),[S]) }+> : 'where' binds { (Just $2, [$1]) }+> | {- empty -} { (Nothing, []) }++Type signatures on value definitions require ScopedTypeVariables (or PatternSignatures, which is deprecated).++> optsig :: { (Maybe (Type L),[S]) }+> : '::' truectype {% checkEnabled ScopedTypeVariables >> return (Just $2, [$1]) }+> | {- empty -} { (Nothing,[]) }++> rhs :: { Rhs L }+> : '=' trueexp { UnGuardedRhs (nIS $1 <++> ann $2 <** [$1]) $2 }+> | gdrhs { GuardedRhss (snd $1) (reverse $ fst $1) }++> gdrhs :: { ([GuardedRhs L],L) }+> : gdrhs gdrh { ($2 : fst $1, snd $1 <++> ann $2) }+> | gdrh { ([$1],ann $1) }++Guards may contain patterns if PatternGuards is enabled, hence quals instead of exp.+> gdrh :: { GuardedRhs L }+> : '|' quals '=' trueexp {% do { checkPatternGuards (fst $2);+> return $ GuardedRhs (nIS $1 <++> ann $4 <** ($1:snd $2 ++ [$3])) (reverse (fst $2)) $4 } }++-----------------------------------------------------------------------------+Expressions++Note: The Report specifies a meta-rule for lambda, let and if expressions+(the exp's that end with a subordinate exp): they extend as far to+the right as possible. That means they cannot be followed by a type+signature or infix application. To implement this without shift/reduce+conflicts, we split exp10 into these expressions (exp10a) and the others+(exp10b). That also means that only an exp0 ending in an exp10b (an exp0b)+can followed by a type signature or infix application. So we duplicate+the exp0 productions to distinguish these from the others (exp0a).++Ugly: We need non-parenthesized post-operators for HaRP, and to parse both+these and normal left sections, we parse both as PostOp and let the post pass+mangle them into the correct form depending on context.++> trueexp :: { Exp L }+> : exp {% checkExpr $1 }++> exp :: { PExp L }+> : exp0b '::' truectype { ExpTypeSig ($1 <> $3 <** [$2]) $1 $3 }+> | exp0 { $1 }+> | exp0b qop { PostOp ($1 <> $2) $1 $2 }+> | exp0b '-<' exp { LeftArrApp ($1 <> $3 <** [$2]) $1 $3 }+> | exp0b '>-' exp { RightArrApp ($1 <> $3 <** [$2]) $1 $3 }+> | exp0b '-<<' exp { LeftArrHighApp ($1 <> $3 <** [$2]) $1 $3 }+> | exp0b '>>-' exp { RightArrHighApp ($1 <> $3 <** [$2]) $1 $3 }++> exp0 :: { PExp L }+> : exp0a { $1 }+> | exp0b { $1 }++> exp0a :: { PExp L }+> : exp0b qop exp10a { InfixApp ($1 <> $3) $1 $2 $3 }+> | exp10a { $1 }++> exp0b :: { PExp L }+> : exp0b qop exp10b { InfixApp ($1 <> $3) $1 $2 $3 }+> | exp10b { $1 }++> exp10a :: { PExp L }+> : '\\' apats '->' exp { Lambda (nIS $1 <++> ann $4 <** [$1,$3]) (reverse $2) $4 }+A let may bind implicit parameters+> | 'let' binds 'in' exp { Let (nIS $1 <++> ann $4 <** [$1,$3]) $2 $4 }+> | 'if' exp 'then' exp 'else' exp { If (nIS $1 <++> ann $6 <** [$1,$3,$5]) $2 $4 $6 }+> | 'proc' apat '->' exp { Proc (nIS $1 <++> ann $4 <** [$1,$3]) $2 $4 }+> | exppragma { $1 }++mdo blocks require the RecursiveDo extension enabled, but the lexer handles that.++> exp10b :: { PExp L }+> : 'case' exp 'of' altslist { let (als, inf, ss) = $4 in Case (nIS $1 <++> inf <** ($1:$3:ss)) $2 als }+> | '-' fexp { NegApp (nIS $1 <++> ann $2 <** [$1]) $2 }+> | 'do' stmtlist { let (sts, inf, ss) = $2 in Do (nIS $1 <++> inf <** $1:ss) sts }+> | 'mdo' stmtlist { let (sts, inf, ss) = $2 in MDo (nIS $1 <++> inf <** $1:ss) sts }+> | fexp { $1 }++> exppragma :: { PExp L }+> : '{-# CORE' STRING '#-}' exp { let Loc l (StringTok (s,_)) = $2 in CorePragma (nIS $1 <++> ann $4 <** [l,$3]) s $4 }+> | '{-# SCC' STRING '#-}' exp { let Loc l (StringTok (s,_)) = $2 in SCCPragma (nIS $1 <++> ann $4 <** [l,$3]) s $4 }+> | '{-# GENERATED' STRING INT ':' INT '-' INT ':' INT '#-}' exp+> { let { Loc l0 (StringTok (s,_)) = $2;+> Loc l1 (IntTok (i1,_)) = $3;+> Loc l2 (IntTok (i2,_)) = $5;+> Loc l3 (IntTok (i3,_)) = $7;+> Loc l4 (IntTok (i4,_)) = $9}+> in GenPragma (nIS $1 <++> ann $11 <** [$1,l0,l1,$4,l2,$6,l3,$8,l4,$10])+> s (fromInteger i1, fromInteger i2)+> (fromInteger i3, fromInteger i4) $11 }++> fexp :: { PExp L }+> {- -- Can't get it to work (get compile errors on the produced .hs):+> : fexp '_' {% checkEnabled FreeSections >> return (App ($1 <> (nIS $2)) $1 (FreeSectSlot (nIS $2))) }+> | fexp aexp { App ($1 <> $2) $1 $2 }+> -}+> : fexp aexp { App ($1 <> $2) $1 $2 }+> | aexp { $1 }++> apats :: { [Pat L] }+> : apats apat { $2 : $1 }+> | apat { [$1] }++> apat :: { Pat L }+> : aexp {% checkPattern $1 }+> | '!' aexp {% checkPattern (BangPat (nIS $1 <++> ann $2 <** [$1]) $2) }++UGLY: Because patterns and expressions are mixed, aexp has to be split into+two rules: One right-recursive and one left-recursive. Otherwise we get two+reduce/reduce-errors (for as-patterns and irrefutable patters).++Even though the variable in an as-pattern cannot be qualified, we use+qvar here to avoid a shift/reduce conflict, and then check it ourselves+(as for vars above).++Non-linear name binding, @:, requires RegularPatterns, but the lexer handles that.++> aexp :: { PExp L }+> : qvar '@' aexp {% do { n <- checkUnQual $1;+> return (AsPat ($1 <> $3 <** [$2]) n $3) } }+> | qvar '@:' aexp {% do { n <- checkUnQual $1;+> return (CAsRP ($1 <> $3 <** [$2]) n $3) } }+> | '~' aexp { IrrPat (nIS $1 <++> ann $2 <** [$1]) $2 }+> | aexp1 { $1 }++Note: The first two alternatives of aexp1 are not necessarily record+updates: they could be labeled constructions.+Generics-style explicit type arguments need the Generics extension, but+we check that in the lexer.++> aexp1 :: { PExp L }+> : aexp1 '{' '}' {% liftM (amap (const (ann $1 <++> nIS $3 <** [$2,$3]))) $ mkRecConstrOrUpdate $1 [] }+> | aexp1 '{' fbinds '}' {% liftM (amap (const (ann $1 <++> nIS $4 <** ($2:reverse (snd $3) ++ [$4]))))+> $ mkRecConstrOrUpdate $1 (reverse (fst $3)) }+> | qvar '{|' truetype '|}' { ExplTypeArg (ann $1 <++> nIS $4 <** [$2,$4]) $1 $3 }+> | aexp2 { $1 }++According to the Report, the left section (e op) is legal iff (e op x)+parses equivalently to ((e) op x). Thus e must be an exp0b.+An implicit parameter can be used as an expression, enabled by the lexer.+Extensions using banana brackets are also enabled by the lexer. The only+thing we need to look at here is the erpats that use no non-standard lexemes.++> aexp2 :: { PExp L }+> : ivar { IPVar (ann $1) $1 }+> | qvar { Var (ann $1) $1 }+> | gcon { $1 }+> | literal { Lit (ann $1) $1 }+> | '(' texp ')' { Paren ($1 <^^> $3 <** [$1,$3]) $2 }+> | '(' texp tsectend { TupleSection ($1 <^^> head (snd $3) <** $1:reverse (snd $3)) (Just $2 : fst $3) }+> | '(' commas texp ')' { TupleSection ($1 <^^> $4 <** $1:reverse ($4:$2))+> (replicate (length $2) Nothing ++ [Just $3]) }+> | '(' commas texp tsectend { TupleSection ($1 <^^> head (snd $4) <** $1:reverse (snd $4 ++ $2))+> (replicate (length $2) Nothing ++ Just $3 : fst $4) }+> | '[' list ']' { amap (\l -> l <** [$3]) $ $2 ($1 <^^> $3 <** [$1]) }+> -- I was unsuccessful in changing '__' to '_' -- tried moving the+> -- production to various places, but always reduce/reduce conflicts...+> -- For now, __ is fine.+> {- | '_' exp {% checkEnabled FreeSections >> return (FreeSectSlot (nIS $1)) $2 } -}+> -- GHC -F still checks with that all LANGUAGE pragmas are known to GHC,+> -- which is unfortunate, as the whole point of the -F option is to+> -- allow -- preprocessing (i.e. maybe the preprocessing strips it).+> | '__' { FreeSectSlot (nIS $1) }+> -- | '__' {% checkEnabled FreeSections >> return (FreeSectSlot (nIS $1)) }+> | '_' { WildCard (nIS $1) }+> | '(' erpats ')' {% checkEnabled RegularPatterns >> return (Paren ($1 <^^> $3 <** [$1,$3]) $2) }+> | '(|' sexps '|)' { SeqRP ($1 <^^> $3 <** ($1:reverse (snd $2) ++ [$3])) $ reverse (fst $2) }+> | '(|' exp '|' quals '|)' { GuardRP ($1 <^^> $5 <** ($1:$3 : snd $4 ++ [$5])) $2 $ (reverse $ fst $4) }+> | xml { $1 }++Template Haskell - all this is enabled in the lexer.+> | IDSPLICE { let Loc l (THIdEscape s) = $1 in SpliceExp (nIS l) $ IdSplice (nIS l) s }+> | '$(' trueexp ')' { SpliceExp ($1 <^^> $3 <** [$1,$3]) $ ParenSplice (ann $2) $2 }+> | '[|' trueexp '|]' { BracketExp ($1 <^^> $3 <** [$1,$3]) $ ExpBracket (ann $2) $2 }+> | '[p|' exp0 '|]' {% do { p <- checkPattern $2;+> return $ BracketExp ($1 <^^> $3 <** [$1,$3]) $ PatBracket (ann p) p } }+> | '[t|' truectype '|]' { let l = $1 <^^> $3 <** [$1,$3] in BracketExp l $ TypeBracket l $2 }+> | '[d|' open topdecls close '|]' { let l = $1 <^^> $5 <** ($1:snd $3 ++ [$5]) in BracketExp l $ DeclBracket l (fst $3) }+> | VARQUOTE qvar { VarQuote (nIS $1 <++> ann $2 <** [$1]) $2 }+> | VARQUOTE qcon { VarQuote (nIS $1 <++> ann $2 <** [$1]) $2 }+> | TYPQUOTE tyvar { TypQuote (nIS $1 <++> ann $2 <** [$1]) (UnQual (ann $2) $2) }+> | TYPQUOTE gtycon { TypQuote (nIS $1 <++> ann $2 <** [$1]) $2 }+> | QUASIQUOTE { let Loc l (THQuasiQuote (n,q)) = $1 in QuasiQuote (nIS l) n q }+End Template Haskell++Begin FreeSect+> {-+> -- | '_[' ']_' { $1 }+> -- | '_[' ']_' { nIS $1 }+> -- | '_[]_' { FSContextOpenClose }+> -- | '_[]_' { FSContextOpenClose (nIS $1) }+> -- | '_[]_' { FSContext UnitCon }+> -- | '_[]_' { FSContext ('_[' <^^> ']_' <** ['_[',']_']) UnitCon }+> -}+> -- Never did figure out how to do this part with the checkEnabled:+> | '_[' texp ']_' { FSContext ($1 <^^> $3 <** [$1,$3]) $2 }+End FreeSect++> commas :: { [S] }+> : commas ',' { $2 : $1 }+> | ',' { [$1] }++> texp :: { PExp L }+> : exp { $1 }+> | qopm exp0 { PreOp ($1 <> $2) $1 $2 }+> | exp '->' exp {% do {checkEnabled ViewPatterns;+> return $ ViewPat ($1 <> $3 <** [$2]) $1 $3} }++> tsectend :: { ([Maybe (PExp L)],[S]) }+> : commas texp tsectend { let (mes, ss) = $3 in (replicate (length $1 - 1) Nothing ++ Just $2 : mes, ss ++ $1) }+> | commas texp ')' { (replicate (length $1 - 1) Nothing ++ [Just $2], $3 : $1) }+> | commas ')' { (replicate (length $1) Nothing, $2 : $1) }++-----------------------------------------------------------------------------+Harp Extensions++> sexps :: { ([PExp L],[S]) }+> : sexps ',' exp { ($3 : fst $1, $2 : snd $1) }+> | exp { ([$1],[]) }++Either patterns are left associative+> erpats :: { PExp L }+> : exp '|' erpats { EitherRP ($1 <> $3 <** [$2]) $1 $3 }+> | exp '|' exp { EitherRP ($1 <> $3 <** [$2]) $1 $3 }++-----------------------------------------------------------------------------+Hsx Extensions - requires XmlSyntax, but the lexer handles all that.++> xml :: { PExp L }+> : '<' name attrs mattr '>' children '</' name '>' {% do { n <- checkEqNames $2 $8;+> let { cn = reverse $6;+> as = reverse $3;+> l = $1 <^^> $9 <** [$1,$5,$7,srcInfoSpan (ann $8),$9] };+> return $ XTag l n as $4 cn } }+> | '<' name attrs mattr '/>' { XETag ($1 <^^> $5 <** [$1,$5]) $2 (reverse $3) $4 }+> | '<%' exp '%>' { XExpTag ($1 <^^> $3 <** [$1,$3]) $2 }+> | '<%>' children '</' '%>' { XChildTag ($1 <^^> $4 <** [$1,$3,$4]) (reverse $2) }++> children :: { [PExp L] }+> : children child { $2 : $1 }+> | {- empty -} { [] }++> child :: { PExp L }+> : PCDATA { let Loc l (XPCDATA pcd) = $1 in XPcdata (nIS l) pcd }+> | '<[' sexps ']>' { XRPats ($1 <^^> $3 <** (snd $2 ++ [$1,$3])) $ reverse (fst $2) }+> | xml { $1 }++> name :: { XName L }+> : xmlname ':' xmlname { let {Loc l1 s1 = $1; Loc l2 s2 = $3}+> in XDomName (nIS l1 <++> nIS l2 <** [l1,$2,l2]) s1 s2 }+> | xmlname { let Loc l str = $1 in XName (nIS l) str }++> xmlname :: { Loc String }+> : VARID { let Loc l (VarId s) = $1 in Loc l s }+> | CONID { let Loc l (ConId s) = $1 in Loc l s }+> | DVARID { let Loc l (DVarId s) = $1 in Loc l $ mkDVar s }+> | xmlkeyword { $1 }++> xmlkeyword :: { Loc String }+> : 'type' { Loc $1 "type" }+> | 'class' { Loc $1 "class" }+> | 'data' { Loc $1 "data" }+> | 'foreign' { Loc $1 "foreign" }+> | 'export' { Loc $1 "export" }+> | 'safe' { Loc $1 "safe" }+> | 'unsafe' { Loc $1 "unsafe" }+> | 'threadsafe' { Loc $1 "threadsafe" }+> | 'stdcall' { Loc $1 "stdcall" }+> | 'ccall' { Loc $1 "ccall" }+> | 'as' { Loc $1 "as" }+> | 'by' { Loc $1 "by" }+> | 'case' { Loc $1 "case" }+> | 'default' { Loc $1 "default" }+> | 'deriving' { Loc $1 "deriving" }+> | 'do' { Loc $1 "do" }+> | 'else' { Loc $1 "else" }+> | 'family' { Loc $1 "family" }+> | 'forall' { Loc $1 "forall" }+> | 'group' { Loc $1 "group" }+> | 'hiding' { Loc $1 "hiding" }+> | 'if' { Loc $1 "if" }+> | 'import' { Loc $1 "import" }+> | 'in' { Loc $1 "in" }+> | 'infix' { Loc $1 "infix" }+> | 'infixl' { Loc $1 "infixl" }+> | 'infixr' { Loc $1 "infixr" }+> | 'instance' { Loc $1 "instance" }+> | 'let' { Loc $1 "let" }+> | 'mdo' { Loc $1 "mdo" }+> | 'module' { Loc $1 "module" }+> | 'newtype' { Loc $1 "newtype" }+> | 'of' { Loc $1 "of" }+> | 'proc' { Loc $1 "proc" }+> | 'rec' { Loc $1 "rec" }+> | 'then' { Loc $1 "then" }+> | 'using' { Loc $1 "using" }+> | 'where' { Loc $1 "where" }+> | 'qualified' { Loc $1 "qualified" }+++> attrs :: { [ParseXAttr L] }+> : attrs attr { $2 : $1 }+> | {- empty -} { [] }++> attr :: { ParseXAttr L }+> : name '=' aexp { XAttr ($1 <> $3 <** [$2]) $1 $3 }++> mattr :: { Maybe (PExp L) }++> : aexp { Just $1 }+> | {-empty-} { Nothing }++-----------------------------------------------------------------------------+List expressions++The rules below are little bit contorted to keep lexps left-recursive while+avoiding another shift/reduce-conflict.++> list :: { L -> PExp L }+> : texp { \l -> List l [$1] }+> | lexps { \l -> let (ps,ss) = $1 in List (l <** reverse ss) (reverse ps) }+> | texp '..' { \l -> EnumFrom (l <** [$2]) $1 }+> | texp ',' exp '..' { \l -> EnumFromThen (l <** [$2,$4]) $1 $3 }+> | texp '..' exp { \l -> EnumFromTo (l <** [$2]) $1 $3 }+> | texp ',' exp '..' exp { \l -> EnumFromThenTo (l <** [$2,$4]) $1 $3 $5 }+> | texp '|' pqualstmts { \l -> let (stss, ss) = $3 in ParComp (l <** ($2:ss)) $1 (reverse stss) }++> lexps :: { ([PExp L],[S]) }+> : lexps ',' texp { let (es, ss) = $1 in ($3 : es, $2 : ss) }+> | texp ',' texp { ([$3,$1], [$2]) }++-----------------------------------------------------------------------------+List comprehensions++> pqualstmts :: { ([[QualStmt L]],[S]) }+> : pqualstmts '|' qualstmts { let { (stss, ss1) = $1;+> (sts, ss2) = $3 }+> in (reverse sts : stss, ss1 ++ [$2] ++ reverse ss2) }+> | qualstmts { let (sts, ss) = $1 in ([reverse sts], reverse ss) }++> qualstmts :: { ([QualStmt L],[S]) }+> : qualstmts ',' qualstmt { let (sts, ss) = $1 in ($3 : sts, $2 : ss) }+> | qualstmt { ([$1],[]) }++> qualstmt :: { QualStmt L }+> : transformqual { $1 }+> | qual { QualStmt (ann $1) $1 }++> transformqual :: { QualStmt L }+> : 'then' trueexp { ThenTrans (nIS $1 <++> ann $2 <** [$1]) $2 }+> | 'then' trueexp 'by' trueexp { ThenBy (nIS $1 <++> ann $4 <** [$1,$3]) $2 $4 }+> | 'then' 'group' 'by' trueexp { GroupBy (nIS $1 <++> ann $4 <** [$1,$2,$3]) $4 }+> | 'then' 'group' 'using' trueexp { GroupUsing (nIS $1 <++> ann $4 <** [$1,$2,$3]) $4 }+> | 'then' 'group' 'by' trueexp 'using' trueexp { GroupByUsing (nIS $1 <++> ann $6 <** [$1,$2,$3,$5]) $4 $6 }++> quals :: { ([Stmt L],[S]) }+> : quals ',' qual { let (sts, ss) = $1 in ($3 : sts, $2 : ss) }+> | qual { ([$1],[]) }++> qual :: { Stmt L }+> : pat '<-' trueexp { Generator ($1 <> $3 <** [$2]) $1 $3 }+> | trueexp { Qualifier (ann $1) $1 }+> | 'let' binds { LetStmt (nIS $1 <++> ann $2 <** [$1]) $2 }+++-----------------------------------------------------------------------------+Case alternatives++> altslist :: { ([Alt L],L,[S]) }+> : '{' alts '}' { (fst $2, $1 <^^> $3, $1:snd $2 ++ [$3]) }+> | open alts close { (fst $2, $1 <^^> $3, $1:snd $2 ++ [$3]) }++> alts :: { ([Alt L],[S]) }+> : optsemis alts1 optsemis { (reverse $ fst $2, $1 ++ snd $2 ++ $3) }++> alts1 :: { ([Alt L],[S]) }+> : alts1 semis alt { ($3 : fst $1, snd $1 ++ $2) }+> | alt { ([$1],[]) }++> alt :: { Alt L }+> : pat ralt optwhere { Alt ($1 <> $2 <+?> (fmap ann) (fst $3) <** snd $3) $1 $2 (fst $3) }++> ralt :: { GuardedAlts L }+> : '->' trueexp { UnGuardedAlt (nIS $1 <++> ann $2 <** [$1]) $2 }+> | gdpats { GuardedAlts (snd $1) (reverse $ fst $1) }++> gdpats :: { ([GuardedAlt L],L) }+> : gdpats gdpat { ($2 : fst $1, snd $1 <++> ann $2) }+> | gdpat { ([$1], ann $1) }++A guard can be a pattern guard if PatternGuards is enabled, hence quals instead of exp0.+> gdpat :: { GuardedAlt L }+> : '|' quals '->' trueexp {% do { checkPatternGuards (fst $2);+> let {l = nIS $1 <++> ann $4 <** ($1:snd $2 ++ [$3])};+> return (GuardedAlt l (reverse (fst $2)) $4) } }++> pat :: { Pat L }+> : exp {% checkPattern $1 }+> | '!' aexp {% checkPattern (BangPat (nIS $1 <++> ann $2 <** [$1]) $2) }+-----------------------------------------------------------------------------+Statement sequences++As per the Report, but with stmt expanded to simplify building the list+without introducing conflicts. This also ensures that the last stmt is+an expression.++TODO: The points can't be added here, must be propagated!++> stmtlist :: { ([Stmt L],L,[S]) }+> : '{' stmts '}' { (fst $2, $1 <^^> $3, $1:snd $2 ++ [$3]) }+> | open stmts close { (fst $2, $1 <^^> $3, $1:snd $2 ++ [$3]) }++> stmts :: { ([Stmt L],[S]) }+> : stmt stmts1 { ($1 : fst $2, snd $2) }+> | ';' stmts { (fst $2, $1 : snd $2) }+> | {- empty -} { ([],[]) }++> stmts1 :: { ([Stmt L],[S]) }+> : ';' stmts { (fst $2, $1 : snd $2) }+> | {- empty -} { ([],[]) }++A let statement may bind implicit parameters.+> stmt :: { Stmt L }+> : 'let' binds { LetStmt (nIS $1 <++> ann $2 <** [$1]) $2 }+> | pat '<-' trueexp { Generator ($1 <> $3 <** [$2]) $1 $3 }+> | trueexp { Qualifier (ann $1) $1 }+> | 'rec' stmtlist { let (stms,inf,ss) = $2 in RecStmt (nIS $1 <++> inf <** $1:ss) stms }++-----------------------------------------------------------------------------+Record Field Update/Construction++> fbinds :: { ([PFieldUpdate L],[S]) }+> : fbinds ',' fbind { let (fbs, ss) = $1 in ($3 : fbs, $2 : ss) }+> | fbind { ([$1],[]) }++Puns and wild cards need the respective extensions enabled.++> fbind :: { PFieldUpdate L }+> : qvar '=' exp { FieldUpdate ($1 <>$3 <** [$2]) $1 $3 }+> | qvar {% checkEnabled NamedFieldPuns >> checkUnQual $1 >>= return . FieldPun (ann $1) }+> | '..' {% checkEnabled RecordWildCards >> return (FieldWildcard (nIS $1)) }++-----------------------------------------------------------------------------+Implicit parameter bindings - need the ImplicitParameter extension enabled, but the lexer handles that.++> ipbinds :: { ([IPBind L],[S]) }+> : optsemis ipbinds1 optsemis { (reverse (fst $2), reverse $1 ++ snd $2 ++ reverse $3) }++> ipbinds1 :: { ([IPBind L],[S]) }+> : ipbinds1 semis ipbind { ($3 : fst $1, snd $1 ++ reverse $2) }+> | ipbind { ([$1],[]) }++> ipbind :: { IPBind L }+> : ivar '=' trueexp { IPBind ($1 <> $3 <** [$2]) $1 $3 }++-----------------------------------------------------------------------------+Variables, Constructors and Operators.++> gcon :: { PExp L }+> : '(' ')' { p_unit_con ($1 <^^> $2 <** [$1,$2]) }+> | '[' ']' { List ($1 <^^> $2 <** [$1,$2]) [] }+> | '(' commas ')' { p_tuple_con ($1 <^^> $3 <** $1:reverse ($3:$2)) Boxed (length $2) }+> | '(#' '#)' { p_unboxed_singleton_con ($1 <^^> $2 <** [$1,$2]) }+> | '(#' commas '#)' { p_tuple_con ($1 <^^> $3 <** $1:reverse ($3:$2)) Unboxed (length $2) }+> | qcon { Con (ann $1) $1 }++> var :: { Name L }+> : varid { $1 }+> | '(' varsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> var_no_safety :: { Name L }+> : varid_no_safety { $1 }+> | '(' varsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> qvar :: { QName L }+> : qvarid { $1 }+> | '(' qvarsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++Implicit parameter+> ivar :: { IPName L }+> : ivarid { $1 }++> con :: { Name L }+> : conid { $1 }+> | '(' consym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> qcon :: { QName L }+> : qconid { $1 }+> | '(' gconsym ')' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> varop :: { Name L }+> : varsym { $1 }+> | '`' varid '`' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> qvarop :: { QName L }+> : qvarsym { $1 }+> | '`' qvarid '`' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> qvaropm :: { QName L }+> : qvarsymm { $1 }+> | '`' qvarid '`' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> conop :: { Name L }+> : consym { $1 }+> | '`' conid '`' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> qconop :: { QName L }+> : gconsym { $1 }+> | '`' qconid '`' { fmap (const ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3])) $2 }++> op :: { Op L }+> : varop { VarOp (ann $1) $1 }+> | conop { ConOp (ann $1) $1 }++> qop :: { QOp L }+> : qvarop { QVarOp (ann $1) $1 }+> | qconop { QConOp (ann $1) $1 }++> qopm :: { QOp L }+> : qvaropm { QVarOp (ann $1) $1 }+> | qconop { QConOp (ann $1) $1 }++> gconsym :: { QName L }+> : ':' { list_cons_name (nIS $1) }+> | qconsym { $1 }++-----------------------------------------------------------------------------+Identifiers and Symbols++> qvarid :: { QName L }+> : varid { UnQual (ann $1) $1 }+> | QVARID { let {Loc l (QVarId q) = $1; nis = nIS l}+> in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q)) }++> varid_no_safety :: { Name L }+> : VARID { let Loc l (VarId v) = $1 in Ident (nIS l) v }+> | 'as' { as_name (nIS $1) }+> | 'qualified' { qualified_name (nIS $1) }+> | 'hiding' { hiding_name (nIS $1) }+> | 'export' { export_name (nIS $1) }+> | 'stdcall' { stdcall_name (nIS $1) }+> | 'ccall' { ccall_name (nIS $1) }++> varid :: { Name L }+> : varid_no_safety { $1 }+> | 'safe' { safe_name (nIS $1) }+> | 'unsafe' { unsafe_name (nIS $1) }+> | 'threadsafe' { threadsafe_name (nIS $1) }+++Implicit parameter+> ivarid :: { IPName L }+> : IDUPID { let Loc l (IDupVarId i) = $1 in IPDup (nIS l) i }+> | ILINID { let Loc l (ILinVarId i) = $1 in IPLin (nIS l) i }++> qconid :: { QName L }+> : conid { UnQual (ann $1) $1 }+> | QCONID { let {Loc l (QConId q) = $1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q)) }++> conid :: { Name L }+> : CONID { let Loc l (ConId c) = $1 in Ident (nIS l) c }++> qconsym :: { QName L }+> : consym { UnQual (ann $1) $1 }+> | QCONSYM { let {Loc l (QConSym q) = $1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q)) }++> consym :: { Name L }+> : CONSYM { let Loc l (ConSym c) = $1 in Symbol (nIS l) c }++> qvarsym :: { QName L }+> : varsym { UnQual (ann $1) $1 }+> | qvarsym1 { $1 }++> qvarsymm :: { QName L }+> : varsymm { UnQual (ann $1) $1 }+> | qvarsym1 { $1 }++> varsym :: { Name L }+> : VARSYM { let Loc l (VarSym v) = $1 in Symbol (nIS l) v }+> | '-' { minus_name (nIS $1) }+> | '!' { bang_name (nIS $1) }+> | '.' { dot_name (nIS $1) }+> | '*' { star_name (nIS $1) }++> varsymm :: { Name L } -- varsym not including '-'+> : VARSYM { let Loc l (VarSym v) = $1 in Symbol (nIS l) v }+> | '!' { bang_name (nIS $1) }+> | '.' { dot_name (nIS $1) }+> | '*' { star_name (nIS $1) }++> qvarsym1 :: { QName L }+> : QVARSYM { let {Loc l (QVarSym q) = $1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q)) }++> literal :: { Literal L }+> : INT { let Loc l (IntTok (i,raw)) = $1 in Int (nIS l) i raw }+> | CHAR { let Loc l (Character (c,raw)) = $1 in Char (nIS l) c raw }+> | RATIONAL { let Loc l (FloatTok (r,raw)) = $1 in Frac (nIS l) r raw }+> | STRING { let Loc l (StringTok (s,raw)) = $1 in String (nIS l) s raw }+> | PRIMINT { let Loc l (IntTokHash (i,raw)) = $1 in PrimInt (nIS l) i raw }+> | PRIMWORD { let Loc l (WordTokHash (w,raw)) = $1 in PrimWord (nIS l) w raw }+> | PRIMFLOAT { let Loc l (FloatTokHash (f,raw)) = $1 in PrimFloat (nIS l) f raw }+> | PRIMDOUBLE { let Loc l (DoubleTokHash (d,raw)) = $1 in PrimDouble (nIS l) d raw }+> | PRIMCHAR { let Loc l (CharacterHash (c,raw)) = $1 in PrimChar (nIS l) c raw }+> | PRIMSTRING { let Loc l (StringHash (s,raw)) = $1 in PrimString (nIS l) s raw }++-----------------------------------------------------------------------------+Layout++> open :: { S } : {% pushCurrentContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x) (return x) -} }++> close :: { S }+> : vccurly { $1 {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -} } -- context popped in lexer.+> | error {% popContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x ++ show x) (return x) -} }++-----------------------------------------------------------------------------+Miscellaneous (mostly renamings)++> modid :: { ModuleName L }+> : CONID { let Loc l (ConId n) = $1 in ModuleName (nIS l) n }+> | QCONID { let Loc l (QConId n) = $1 in ModuleName (nIS l) (fst n ++ '.':snd n) }++> tyconorcls :: { Name L }+> : con { $1 }++> qtyconorcls :: { QName L }+> : qcon { $1 }++> tyvar :: { Name L }+> : varid { $1 }++> qtyvarop :: { QName L }+> qtyvarop : '`' tyvar '`' { UnQual ($1 <^^> $3 <** [$1, srcInfoSpan (ann $2), $3]) $2 }+> | tyvarsym { UnQual (ann $1) $1 }++> tyvarsym :: { Name L }+> tyvarsym : VARSYM { let Loc l (VarSym x) = $1 in Symbol (nIS l) x }++-----------------------------------------------------------------------------++> {++> type L = SrcSpanInfo -- just for convenience+> type S = SrcSpan++> parseError :: Loc Token -> P a+> parseError t = fail $ "Parse error: " ++ showToken (unLoc t)++> (<>) :: (Annotated a, Annotated b) => a SrcSpanInfo -> b SrcSpanInfo -> SrcSpanInfo+> a <> b = ann a <++> ann b+>+> infixl 6 <>++> nIS = noInfoSpan+> iS = infoSpan+++> -- | Parse of a string, which should contain a complete Haskell module.+> parseModule :: String -> ParseResult (Module SrcSpanInfo)+> parseModule = simpleParse mparseModule++> -- | Parse of a string containing a complete Haskell module, using an explicit mode.+> parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)+> parseModuleWithMode = modeParse mparseModule++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])+> parseModuleWithComments = commentParse mparseModule++> -- | Parse of a string containing a Haskell expression.+> parseExp :: String -> ParseResult (Exp SrcSpanInfo)+> parseExp = simpleParse mparseExp++> -- | Parse of a string containing a Haskell expression, using an explicit mode.+> parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)+> parseExpWithMode = modeParse mparseExp++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])+> parseExpWithComments = commentParse mparseExp++> -- | Parse of a string containing a Haskell pattern.+> parsePat :: String -> ParseResult (Pat SrcSpanInfo)+> parsePat = simpleParse mparsePat++> -- | Parse of a string containing a Haskell pattern, using an explicit mode.+> parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)+> parsePatWithMode = modeParse mparsePat++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])+> parsePatWithComments = commentParse mparsePat++> -- | Parse of a string containing a Haskell top-level declaration.+> parseDecl :: String -> ParseResult (Decl SrcSpanInfo)+> parseDecl = simpleParse mparseDecl++> -- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.+> parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)+> parseDeclWithMode = modeParse mparseDecl++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])+> parseDeclWithComments = commentParse mparseDecl++> -- | Parse of a string containing a Haskell type.+> parseType :: String -> ParseResult (Type SrcSpanInfo)+> parseType = runParser mparseType++> -- | Parse of a string containing a Haskell type, using an explicit mode.+> parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)+> parseTypeWithMode mode = runParserWithMode mode mparseType++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])+> parseTypeWithComments mode str = runParserWithModeComments mode mparseType str++> -- | Parse of a string containing a Haskell statement.+> parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)+> parseStmt = runParser mparseStmt++> -- | Parse of a string containing a Haskell type, using an explicit mode.+> parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)+> parseStmtWithMode mode = runParserWithMode mode mparseStmt++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])+> parseStmtWithComments mode str = runParserWithModeComments mode mparseStmt str+++> simpleParse :: AppFixity a => P (a L) -> String -> ParseResult (a L)+> simpleParse p = applyFixities preludeFixities <=< runParser p++> modeParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L)+> modeParse p mode = applyFixities' (fixities mode) <=< runParserWithMode mode p++> commentParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L, [Comment])+> commentParse p mode str = do (ast, cs) <- runParserWithModeComments mode p str+> ast' <- applyFixities' (fixities mode) ast+> return (ast', cs)++> -- | Partial parse of a string starting with a series of top-level option pragmas.+> getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]+> getTopPragmas = runParser (mfindOptPragmas >>= \(ps,_,_) -> return ps)++> -- | Parse of a string, which should contain a complete Haskell module.+> parseModules :: String -> ParseResult [Module SrcSpanInfo]+> parseModules = mapM (applyFixities preludeFixities) <=< runParser mparseModules++> -- | Parse of a string containing a complete Haskell module, using an explicit mode.+> parseModulesWithMode :: ParseMode -> String -> ParseResult [Module SrcSpanInfo]+> parseModulesWithMode mode = mapM (applyFixities' (fixities mode)) <=< runParserWithMode mode mparseModules++> -- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+> parseModulesWithComments :: ParseMode -> String -> ParseResult ([Module SrcSpanInfo], [Comment])+> parseModulesWithComments mode str = do (ast,cs) <- runParserWithModeComments mode mparseModules str+> ast' <- mapM (applyFixities' (fixities mode)) ast+> return (ast', cs)+>+> applyFixities' :: (AppFixity a) => Maybe [Fixity] -> a L -> ParseResult (a L)+> applyFixities' Nothing ast = return ast+> applyFixities' (Just fixs) ast = applyFixities fixs ast+>++> }
+ HSE/Lexer.hs view
@@ -0,0 +1,1326 @@+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Annotated.Lexer+-- Copyright : (c) The GHC Team, 1997-2000+-- (c) Niklas Broberg, 2004-2009+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- Lexer for Haskell, with some extensions.+--+-----------------------------------------------------------------------------++-- ToDo: Introduce different tokens for decimal, octal and hexadecimal (?)+-- ToDo: FloatTok should have three parts (integer part, fraction, exponent) (?)+-- ToDo: Use a lexical analyser generator (lx?)++module HSE.Lexer (Token(..), showToken, lexer) where++import HSE.ParseMonad+import HSE.SrcLoc+import HSE.Comments+import HSE.Extension+import HSE.ExtScheme++import Data.Char+import Data.Ratio+import Data.List (intersperse)+import Control.Monad (when)++-- import Debug.Trace (trace)++data Token+ = VarId String+ | QVarId (String,String)+ | IDupVarId (String) -- duplicable implicit parameter+ | ILinVarId (String) -- linear implicit parameter+ | ConId String+ | QConId (String,String)+ | DVarId [String] -- to enable varid's with '-' in them+ | VarSym String+ | ConSym String+ | QVarSym (String,String)+ | QConSym (String,String)+ | IntTok (Integer, String)+ | FloatTok (Rational, String)+ | Character (Char, String)+ | StringTok (String, String)+ | IntTokHash (Integer, String) -- 1#+ | WordTokHash (Integer, String) -- 1##+ | FloatTokHash (Rational, String) -- 1.0#+ | DoubleTokHash (Rational, String) -- 1.0##+ | CharacterHash (Char, String) -- c#+ | StringHash (String, String) -- "Hello world!"#++-- Symbols++ | LeftParen+ | RightParen+ | LeftHashParen+ | RightHashParen+ | LeftCurlyBar+ | RightCurlyBar+ | SemiColon+ | LeftCurly+ | RightCurly+ | VRightCurly -- a virtual close brace+ | LeftSquare+ | RightSquare+ | Comma+ | DoubleUnderscore+ | Underscore+ | BackQuote++-- Reserved operators++ | Dot -- reserved for use with 'forall x . x'+ | DotDot+ | Colon+ | DoubleColon+ | Equals+ | Backslash+ | Bar+ | LeftArrow+ | RightArrow+ | At+ | Tilde+ | DoubleArrow+ | Minus+ | Exclamation+ | Star+ | LeftArrowTail -- >-+ | RightArrowTail -- -<+ | LeftDblArrowTail -- >>-+ | RightDblArrowTail -- -<<++-- Template Haskell+ | THExpQuote -- [| or [e|+ | THPatQuote -- [p|+ | THDecQuote -- [d|+ | THTypQuote -- [t|+ | THCloseQuote -- |]+ | THIdEscape (String) -- dollar x+ | THParenEscape -- dollar (+ | THVarQuote -- 'x (but without the x)+ | THTyQuote -- ''T (but without the T)+ | THQuasiQuote (String,String) -- [$...|...]++-- FreeSect+ | FSContextOpen -- _[+ | FSContextClose -- ]_+-- | FSContextOpenClose -- _[]_++-- HaRP+ | RPGuardOpen -- (|+ | RPGuardClose -- |)+ | RPCAt -- @:++-- Hsx+ | XCodeTagOpen -- <%+ | XCodeTagClose -- %>+ | XStdTagOpen -- <+ | XStdTagClose -- >+ | XCloseTagOpen -- </+ | XEmptyTagClose -- />+ | XChildTagOpen -- <%> (note that close doesn't exist, it's XCloseTagOpen followed by XCodeTagClose)+ | XPCDATA String+ | XRPatOpen -- <[+ | XRPatClose -- ]>++-- Pragmas++ | PragmaEnd -- #-}+ | RULES+ | INLINE Bool+ | INLINE_CONLIKE+ | SPECIALISE+ | SPECIALISE_INLINE Bool+ | SOURCE+ | DEPRECATED+ | WARNING+ | SCC+ | GENERATED+ | CORE+ | UNPACK+ | OPTIONS (Maybe String,String)+-- | CFILES String+-- | INCLUDE String+ | LANGUAGE+ | ANN++-- Reserved Ids++ | KW_As+ | KW_By -- transform list comprehensions+ | KW_Case+ | KW_Class+ | KW_Data+ | KW_Default+ | KW_Deriving+ | KW_Do+ | KW_MDo+ | KW_Else+ | KW_Family -- indexed type families+ | KW_Forall -- universal/existential types+ | KW_Group -- transform list comprehensions+ | KW_Hiding+ | KW_If+ | KW_Import+ | KW_In+ | KW_Infix+ | KW_InfixL+ | KW_InfixR+ | KW_Instance+ | KW_Let+ | KW_Module+ | KW_NewType+ | KW_Of+ | KW_Proc -- arrows+ | KW_Rec -- arrows+ | KW_Then+ | KW_Type+ | KW_Using -- transform list comprehensions+ | KW_Where+ | KW_Qualified++ -- FFI+ | KW_Foreign+ | KW_Export+ | KW_Safe+ | KW_Unsafe+ | KW_Threadsafe+ | KW_StdCall+ | KW_CCall++ | EOF+ deriving (Eq,Show)++reserved_ops :: [(String,(Token, Maybe ExtScheme))]+reserved_ops = [+ ( "..", (DotDot, Nothing) ),+ ( ":", (Colon, Nothing) ),+ ( "::", (DoubleColon, Nothing) ),+ ( "=", (Equals, Nothing) ),+ ( "\\", (Backslash, Nothing) ),+ ( "|", (Bar, Nothing) ),+ ( "<-", (LeftArrow, Nothing) ),+ ( "->", (RightArrow, Nothing) ),+ ( "@", (At, Nothing) ),+ ( "@:", (RPCAt, Just (Any [RegularPatterns])) ),+ ( "~", (Tilde, Nothing) ),+ ( "=>", (DoubleArrow, Nothing) ),+ ( "*", (Star, Just (Any [KindSignatures])) ),+ -- Arrows notation+ ( "-<", (LeftArrowTail, Just (Any [Arrows])) ),+ ( ">-", (RightArrowTail, Just (Any [Arrows])) ),+ ( "-<<", (LeftDblArrowTail, Just (Any [Arrows])) ),+ ( ">>-", (RightDblArrowTail, Just (Any [Arrows])) ),+ -- Unicode notation+ ( "\x2190", (LeftArrow, Just (Any [UnicodeSyntax])) ),+ ( "\x2192", (RightArrow, Just (Any [UnicodeSyntax])) ),+ ( "\x21d2", (DoubleArrow, Just (Any [UnicodeSyntax])) ),+ ( "\x2237", (DoubleColon, Just (Any [UnicodeSyntax])) ),+ ( "\x2919", (LeftArrowTail, Just (All [UnicodeSyntax, Arrows])) ),+ ( "\x291a", (RightArrowTail, Just (All [UnicodeSyntax, Arrows])) ),+ ( "\x291b", (LeftDblArrowTail, Just (All [UnicodeSyntax, Arrows])) ),+ ( "\x291c", (RightDblArrowTail, Just (All [UnicodeSyntax, Arrows])) ),+ ( "\x2605", (Star, Just (All [UnicodeSyntax, KindSignatures])) )+ ]++special_varops :: [(String,(Token, Maybe ExtScheme))]+special_varops = [+ -- the dot is only a special symbol together with forall, but can still be used as function composition+ ( ".", (Dot, Just (Any [ExplicitForall, ExistentialQuantification])) ),+ ( "-", (Minus, Nothing) ),+ ( "!", (Exclamation, Nothing) )+ ]++reserved_ids :: [(String,(Token, Maybe ExtScheme))]+reserved_ids = [+ ( "__", (DoubleUnderscore, Nothing) ),+ ( "_", (Underscore, Nothing) ),+ ( "by", (KW_By, Just (Any [TransformListComp])) ),+ ( "case", (KW_Case, Nothing) ),+ ( "class", (KW_Class, Nothing) ),+ ( "data", (KW_Data, Nothing) ),+ ( "default", (KW_Default, Nothing) ),+ ( "deriving", (KW_Deriving, Nothing) ),+ ( "do", (KW_Do, Nothing) ),+ ( "else", (KW_Else, Nothing) ),+ ( "family", (KW_Family, Just (Any [TypeFamilies])) ), -- indexed type families+ ( "forall", (KW_Forall, Just (Any [ExplicitForall, ExistentialQuantification])) ), -- universal/existential quantification+ ( "group", (KW_Group, Just (Any [TransformListComp])) ),+ ( "if", (KW_If, Nothing) ),+ ( "import", (KW_Import, Nothing) ),+ ( "in", (KW_In, Nothing) ),+ ( "infix", (KW_Infix, Nothing) ),+ ( "infixl", (KW_InfixL, Nothing) ),+ ( "infixr", (KW_InfixR, Nothing) ),+ ( "instance", (KW_Instance, Nothing) ),+ ( "let", (KW_Let, Nothing) ),+ ( "mdo", (KW_MDo, Just (Any [RecursiveDo])) ),+ ( "module", (KW_Module, Nothing) ),+ ( "newtype", (KW_NewType, Nothing) ),+ ( "of", (KW_Of, Nothing) ),+ ( "proc", (KW_Proc, Just (Any [Arrows])) ),+ ( "rec", (KW_Rec, Just (Any [Arrows])) ),+ ( "then", (KW_Then, Nothing) ),+ ( "type", (KW_Type, Nothing) ),+ ( "using", (KW_Using, Just (Any [TransformListComp])) ),+ ( "where", (KW_Where, Nothing) ),++-- FFI+ ( "foreign", (KW_Foreign, Just (Any [ForeignFunctionInterface])) ),++-- Unicode+ ( "\x2200", (KW_Forall, Just (All [UnicodeSyntax, ExplicitForall])) )+ ]+++special_varids :: [(String,(Token, Maybe ExtScheme))]+special_varids = [+ ( "as", (KW_As, Nothing) ),+ ( "qualified", (KW_Qualified, Nothing) ),+ ( "hiding", (KW_Hiding, Nothing) ),++-- FFI+ ( "export", (KW_Export, Just (Any [ForeignFunctionInterface])) ),+ ( "safe", (KW_Safe, Just (Any [ForeignFunctionInterface])) ),+ ( "unsafe", (KW_Unsafe, Just (Any [ForeignFunctionInterface])) ),+ ( "threadsafe", (KW_Threadsafe, Just (Any [ForeignFunctionInterface])) ),+ ( "stdcall", (KW_StdCall, Just (Any [ForeignFunctionInterface])) ),+ ( "ccall", (KW_CCall, Just (Any [ForeignFunctionInterface])) )+ ]++pragmas :: [(String,Token)]+pragmas = [+ ( "rules", RULES ),+ ( "inline", INLINE True ),+ ( "noinline", INLINE False ),+ ( "notinline", INLINE False ),+ ( "specialise", SPECIALISE ),+ ( "specialize", SPECIALISE ),+ ( "source", SOURCE ),+ ( "deprecated", DEPRECATED ),+ ( "warning", WARNING ),+ ( "ann", ANN ),+ ( "scc", SCC ),+ ( "generated", GENERATED ),+ ( "core", CORE ),+ ( "unpack", UNPACK ),+ ( "language", LANGUAGE ),+ ( "options", OPTIONS undefined ) -- we'll tweak it before use - promise!+-- ( "cfiles", CFILES undefined ), -- same here...+-- ( "include", INCLUDE undefined ) -- ...and here!+ ]++isIdent, isHSymbol :: Char -> Bool+isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_'++isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'"))++matchChar :: Char -> String -> Lex a ()+matchChar c msg = do+ s <- getInput+ if null s || head s /= c then fail msg else discard 1++-- The top-level lexer.+-- We need to know whether we are at the beginning of the line to decide+-- whether to insert layout tokens.++lexer :: (Loc Token -> P a) -> P a+lexer = runL topLexer++topLexer :: Lex a (Loc Token)+topLexer = do+ b <- pullCtxtFlag+ if b then -- trace (show cf ++ ": " ++ show VRightCurly) $+ setBOL >> getSrcLocL >>= \l -> return (Loc (mkSrcSpan l l) VRightCurly) -- the lex context state flags that we must do an empty {} - UGLY+ else do+ bol <- checkBOL+ (bol, ws) <- lexWhiteSpace bol+ -- take care of whitespace in PCDATA+ ec <- getExtContext+ case ec of+ -- if there was no linebreak, and we are lexing PCDATA,+ -- then we want to care about the whitespace.+ -- We don't bother to test for XmlSyntax, since we+ -- couldn't end up in ChildCtxt otherwise.+ Just ChildCtxt | not bol && ws -> getSrcLocL >>= \l -> return $ Loc (mkSrcSpan l l) $ XPCDATA " "+ _ -> do startToken+ sl <- getSrcLocL+ t <- if bol then lexBOL -- >>= \t -> trace ("BOL: " ++ show t) (return t)+ else lexToken -- >>= \t -> trace (show t) (return t)+ el <- getSrcLocL+ return $ Loc (mkSrcSpan sl el) t++lexWhiteSpace :: Bool -> Lex a (Bool, Bool)+lexWhiteSpace bol = do+ s <- getInput+ ignL <- ignoreLinePragmasL+ case s of+ -- If we find a recognised pragma, we don't want to treat it as a comment.+ '{':'-':'#':rest | isRecognisedPragma rest -> return (bol, False)+ | isLinePragma rest && not ignL -> do + (l, fn) <- lexLinePragma+ setSrcLineL l+ setLineFilenameL fn+ lexWhiteSpace True+ '{':'-':_ -> do+ loc <- getSrcLocL+ discard 2+ (bol, c) <- lexNestedComment bol ""+ loc2 <- getSrcLocL+ pushComment $ Comment True (mkSrcSpan loc loc2) (reverse c)+ (bol, _) <- lexWhiteSpace bol+ return (bol, True)+ '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do+ loc <- getSrcLocL+ discard 2+ dashes <- lexWhile (== '-')+ rest <- lexWhile (/= '\n')+ s' <- getInput+ loc2 <- getSrcLocL+ let com = Comment False (mkSrcSpan loc loc2) $ dashes ++ rest+ case s' of+ [] -> pushComment com >> return (False, True)+ _ -> do+ pushComment com+ lexNewline+ lexWhiteSpace True+ return (True, True)+ '\n':_ -> do+ lexNewline+ lexWhiteSpace True+ return (True, True)+ '\t':_ -> do+ lexTab+ (bol, _) <- lexWhiteSpace bol+ return (bol, True)+ c:_ | isSpace c -> do+ discard 1+ (bol, _) <- lexWhiteSpace bol+ return (bol, True)+ _ -> return (bol, False)++isRecognisedPragma, isLinePragma :: String -> Bool+isRecognisedPragma str = let pragma = map toLower . takeWhile isAlphaNum . dropWhile isSpace $ str+ in case lookup pragma pragmas of+ Nothing -> False+ _ -> True++isLinePragma str = let pragma = map toLower . takeWhile isAlphaNum . dropWhile isSpace $ str+ in case pragma of+ "line" -> True+ _ -> False++lexLinePragma :: Lex a (Int, String)+lexLinePragma = do+ discard 3 -- {-#+ lexWhile isSpace+ discard 4 -- LINE+ lexWhile isSpace+ i <- lexWhile isDigit+ lexWhile isSpace+ matchChar '"' "Improperly formatted LINE pragma"+ fn <- lexWhile (/= '"')+ matchChar '"' "Impossible - lexLinePragma"+ lexWhile isSpace+ mapM (flip matchChar "Improperly formatted LINE pragma") "#-}"+ lexNewline+ return (read i, fn)++lexNestedComment :: Bool -> String -> Lex a (Bool, String)+lexNestedComment bol str = do+ s <- getInput+ case s of+ '-':'}':_ -> discard 2 >> return (bol, str)+ '{':'-':_ -> do+ discard 2+ (bol, c) <- lexNestedComment bol ("-{" ++ str) -- rest of the subcomment+ lexNestedComment bol ("}-" ++ c ) -- rest of this comment+ '\t':_ -> lexTab >> lexNestedComment bol ('\t':str)+ '\n':_ -> lexNewline >> lexNestedComment True ('\n':str)+ c:_ -> discard 1 >> lexNestedComment bol (c:str)+ [] -> fail "Unterminated nested comment"++-- When we are lexing the first token of a line, check whether we need to+-- insert virtual semicolons or close braces due to layout.++lexBOL :: Lex a Token+lexBOL = do+ pos <- getOffside+ -- trace ("Off: " ++ (show pos)) $ do+ case pos of+ LT -> do+ -- trace "layout: inserting '}'\n" $+ -- Set col to 0, indicating that we're still at the+ -- beginning of the line, in case we need a semi-colon too.+ -- Also pop the context here, so that we don't insert+ -- another close brace before the parser can pop it.+ setBOL+ popContextL "lexBOL"+ return VRightCurly+ EQ ->+ -- trace "layout: inserting ';'\n" $+ return SemiColon+ GT -> lexToken++lexToken :: Lex a Token+lexToken = do+ ec <- getExtContext+ -- we don't bother to check XmlSyntax since we couldn't+ -- have ended up in a non-Nothing context if it wasn't+ -- enabled.+ case ec of+ Just HarpCtxt -> lexHarpToken+ Just TagCtxt -> lexTagCtxt+ Just CloseTagCtxt -> lexCloseTagCtxt+ Just ChildCtxt -> lexChildCtxt+ Just CodeTagCtxt -> lexCodeTagCtxt+ _ -> lexStdToken+++lexChildCtxt :: Lex a Token+lexChildCtxt = do+ -- if we ever end up here, then XmlSyntax must be on.+ s <- getInput+ case s of+ '<':'%':'>':_ -> do discard 3+ pushExtContextL ChildCtxt+ return XChildTagOpen+ '<':'%':_ -> do discard 2+ pushExtContextL CodeTagCtxt+ return XCodeTagOpen+ '<':'/':_ -> do discard 2+ popExtContextL "lexChildCtxt"+ pushExtContextL CloseTagCtxt+ return XCloseTagOpen+ '<':'[':_ -> do discard 2+ pushExtContextL HarpCtxt+ return XRPatOpen+ '<':_ -> do discard 1+ pushExtContextL TagCtxt+ return XStdTagOpen+ _ -> lexPCDATA+++lexPCDATA :: Lex a Token+lexPCDATA = do+ -- if we ever end up here, then XmlSyntax must be on.+ s <- getInput+ case s of+ [] -> return EOF+ _ -> case s of+ '\n':_ -> do+ x <- lexNewline >> lexPCDATA+ case x of+ XPCDATA p -> return $ XPCDATA $ '\n':p+ EOF -> return EOF+ '<':_ -> return $ XPCDATA ""+ _ -> do let pcd = takeWhile (\c -> not $ elem c "<\n") s+ l = length pcd+ discard l+ x <- lexPCDATA+ case x of+ XPCDATA pcd' -> return $ XPCDATA $ pcd ++ pcd'+ EOF -> return EOF+++lexCodeTagCtxt :: Lex a Token+lexCodeTagCtxt = do+ -- if we ever end up here, then XmlSyntax must be on.+ s <- getInput+ case s of+ '%':'>':_ -> do discard 2+ popExtContextL "lexCodeTagContext"+ return XCodeTagClose+ _ -> lexStdToken++lexCloseTagCtxt :: Lex a Token+lexCloseTagCtxt = do+ -- if we ever end up here, then XmlSyntax must be on.+ s <- getInput+ case s of+ '%':'>':_ -> do discard 2+ popExtContextL "lexCloseTagCtxt"+ return XCodeTagClose+ '>':_ -> do discard 1+ popExtContextL "lexCloseTagCtxt"+ return XStdTagClose+ _ -> lexStdToken++lexTagCtxt :: Lex a Token+lexTagCtxt = do+ -- if we ever end up here, then XmlSyntax must be on.+ s <- getInput+ case s of+ '/':'>':_ -> do discard 2+ popExtContextL "lexTagCtxt: Empty tag"+ return XEmptyTagClose+ '>':_ -> do discard 1+ popExtContextL "lexTagCtxt: Standard tag"+ pushExtContextL ChildCtxt+ return XStdTagClose+ _ -> lexStdToken++lexHarpToken :: Lex a Token+lexHarpToken = do+ -- if we ever end up here, then RegularPatterns must be on.+ s <- getInput+ case s of+ ']':'>':_ -> do discard 2+ popExtContextL "lexHarpToken"+ return XRPatClose+ _ -> lexStdToken++lexStdToken :: Lex a Token+lexStdToken = do+ s <- getInput+ exts <- getExtensionsL+ case s of+ [] -> return EOF++ '0':c:d:_ | toLower c == 'o' && isOctDigit d -> do+ discard 2+ (n, str) <- lexOctal+ return (IntTok (n, '0':c:str))+ | toLower c == 'x' && isHexDigit d -> do+ discard 2+ (n, str) <- lexHexadecimal+ return (IntTok (n, '0':c:str))++ -- implicit parameters+ '?':c:_ | isLower c && ImplicitParams `elem` exts -> do+ discard 1+ id <- lexWhile isIdent+ return $ IDupVarId id++ '%':c:_ | isLower c && ImplicitParams `elem` exts -> do+ discard 1+ id <- lexWhile isIdent+ return $ ILinVarId id+ -- end implicit parameters++ -- harp+ '(':'|':c:_ | isHSymbol c -> discard 1 >> return LeftParen+ '(':'|':_ | RegularPatterns `elem` exts ->+ do discard 2+ return RPGuardOpen+ '|':')':_ | RegularPatterns `elem` exts ->+ do discard 2+ return RPGuardClose+ {- This is handled by the reserved_ops above.+ '@':':':_ | RegularPatterns `elem` exts ->+ do discard 2+ return RPCAt -}++ -- template haskell+ '[':'|':_ | TemplateHaskell `elem` exts -> do+ discard 2+ return $ THExpQuote++ '[':c:'|':_ | c == 'e' && TemplateHaskell `elem` exts -> do+ discard 3+ return $ THExpQuote+ | c == 'p' && TemplateHaskell `elem` exts -> do+ discard 3+ return THPatQuote+ | c == 'd' && TemplateHaskell `elem` exts -> do+ discard 3+ return THDecQuote+ | c == 't' && TemplateHaskell `elem` exts -> do+ discard 3+ return THTypQuote+ '[':'$':c:_ | isLower c && QuasiQuotes `elem` exts ->+ discard 2 >> lexQuasiQuote++ '|':']':_ | TemplateHaskell `elem` exts -> do+ discard 2+ return THCloseQuote++ '$':c:_ | isLower c && TemplateHaskell `elem` exts -> do+ discard 1+ id <- lexWhile isIdent+ return $ THIdEscape id+ | c == '(' && TemplateHaskell `elem` exts -> do+ discard 2+ return THParenEscape+ -- end template haskell++ -- freesect+ -- As for __ , it is defined as a reserved id (DoubleUnderscore).+ -- GHC -F still checks with that all LANGUAGE pragmas are known to GHC,+ -- which is unfortunate, as the whole point of the -F option is to+ -- allow -- preprocessing (i.e. maybe the preprocessing strips it).+{-+ -- These are rejected by the parser anyhow, but I thought+ -- it would be nice to control that behaviour. No luck however,+ -- from here it looks like I'd need to invent a whole new token+ -- and make parallel edits through almost all teh HSE files as+ -- for FreeSectSlot and FSContext. Can't use FSContext because+ -- it takes an Exp ... could make that a Maybe Exp or a [Exp]+ -- I guess, that would be one way...+ '_':'[':']':'_':_ -> do discard 4 >> lexStdToken+-- '_':'[':']':'_':_ | FreeSections `elem` exts ->+{-+ do discard 4+ return lexStdToken+ do discard 4+ return FSContextOpenClose+-}+-}+ '_':'[':_ ->+-- '_':'[':_ | FreeSections `elem` exts ->+ do discard 2+ return FSContextOpen+ ']':'_':_ ->+-- ']':'_':_ | FreeSections `elem` exts ->+ do discard 2+ return FSContextClose+ -- end freesect++ -- hsx+ '<':'%':c:_ | XmlSyntax `elem` exts -> do + case c of+ '>' -> do discard 3+ pushExtContextL ChildCtxt+ return XChildTagOpen+ _ -> do discard 2+ pushExtContextL CodeTagCtxt+ return XCodeTagOpen+ '<':c:_ | isAlpha c && XmlSyntax `elem` exts -> do+ discard 1+ pushExtContextL TagCtxt+ return XStdTagOpen+ -- end hsx++ '(':'#':_ | UnboxedTuples `elem` exts -> do discard 2 >> return LeftHashParen++ '#':')':_ | UnboxedTuples `elem` exts -> do discard 2 >> return RightHashParen++ '{':'|':_ | Generics `elem` exts -> do discard 2 >> return LeftCurlyBar++ '|':'}':_ | Generics `elem` exts -> do discard 2 >> return RightCurlyBar++ -- pragmas++ '{':'-':'#':_ -> do discard 3 >> lexPragmaStart++ '#':'-':'}':_ -> do discard 3 >> return PragmaEnd++ c:_ | isDigit c -> lexDecimalOrFloat++ | isUpper c -> lexConIdOrQual ""++ | isLower c || c == '_' -> do+ idents <- lexIdents+ case idents of+ [ident] -> case lookup ident (reserved_ids ++ special_varids) of+ Just (keyword, scheme) -> do+ -- check if an extension keyword is enabled+ if isEnabled scheme exts+ then flagKW keyword >> return keyword+ else return $ VarId ident+ Nothing -> return $ VarId ident+ _ -> return $ DVarId idents++ | isHSymbol c -> do+ sym <- lexWhile isHSymbol+ return $ case lookup sym (reserved_ops ++ special_varops) of+ Just (t , scheme) ->+ -- check if an extension op is enabled+ if isEnabled scheme exts+ then t+ else case c of+ ':' -> ConSym sym+ _ -> VarSym sym+ Nothing -> case c of+ ':' -> ConSym sym+ _ -> VarSym sym++ | otherwise -> do+ discard 1+ case c of++ -- First the special symbols+ '(' -> return LeftParen+ ')' -> return RightParen+ ',' -> return Comma+ ';' -> return SemiColon+ '[' -> return LeftSquare+ ']' -> return RightSquare+ '`' -> return BackQuote+ '{' -> do+ pushContextL NoLayout+ return LeftCurly+ '}' -> do+ popContextL "lexStdToken"+ return RightCurly++ '\'' -> lexCharacter+ '"' -> lexString++ _ -> fail ("Illegal character \'" ++ show c ++ "\'\n")++ where lexIdents :: Lex a [String]+ lexIdents = do+ ident <- lexWhile isIdent+ s <- getInput+ exts <- getExtensionsL+ case s of+ -- This is the only way we can get more than one ident in the list+ -- and it requires XmlSyntax to be on.+ '-':c:_ | XmlSyntax `elem` exts && isAlpha c -> do+ discard 1+ idents <- lexIdents+ return $ ident : idents+ '#':_ | MagicHash `elem` exts -> do+ discard 1+ return [ident ++ "#"]+ _ -> return [ident]++ lexQuasiQuote :: Lex a Token+ lexQuasiQuote = do+ -- We've seen and dropped [$ already+ ident <- lexWhile isIdent+ matchChar '|' "Malformed quasi-quote quoter"+ body <- lexQQBody+ return $ THQuasiQuote (ident, body)++ lexQQBody :: Lex a String+ lexQQBody = do+ s <- getInput+ case s of+ '\\':']':_ -> do discard 2+ str <- lexQQBody+ return (']':str)+ '\\':'|':_ -> do discard 2+ str <- lexQQBody+ return ('|':str)+ '|':']':_ -> discard 2 >> return ""+ '|':_ -> do discard 1+ str <- lexQQBody+ return ('|':str)+ ']':_ -> do discard 1+ str <- lexQQBody+ return (']':str)+ '\\':_ -> do discard 1+ str <- lexQQBody+ return ('\\':str)+ '\n':_ -> do lexNewline+ str <- lexQQBody+ return ('\n':str)+ [] -> fail "Unexpected end of input while lexing quasi-quoter"+ _ -> do str <- lexWhile (not . (`elem` "\\|\n"))+ rest <- lexQQBody+ return (str++rest)++lexPragmaStart :: Lex a Token+lexPragmaStart = do+ lexWhile isSpace+ pr <- lexWhile isAlphaNum+ case lookup (map toLower pr) pragmas of+ Just (INLINE True) -> do+ s <- getInput+ case map toLower s of+ '_':'c':'o':'n':'l':'i':'k':'e':_ -> do+ discard 8+ return $ INLINE_CONLIKE+ _ -> return $ INLINE True+ Just SPECIALISE -> do+ s <- getInput+ case dropWhile isSpace $ map toLower s of+ 'i':'n':'l':'i':'n':'e':_ -> do+ lexWhile isSpace+ discard 6+ return $ SPECIALISE_INLINE True+ 'n':'o':'i':'n':'l':'i':'n':'e':_ -> do+ lexWhile isSpace+ discard 8+ return $ SPECIALISE_INLINE False+ 'n':'o':'t':'i':'n':'l':'i':'n':'e':_ -> do+ lexWhile isSpace+ discard 9+ return $ SPECIALISE_INLINE False+ _ -> return SPECIALISE++ Just (OPTIONS _) -> do -- see, I promised we'd mask out the 'undefined'+ s <- getInput+ case s of+ '_':_ -> do+ discard 1+ com <- lexWhile isIdent+ rest <- lexRawPragma+ return $ OPTIONS (Just com, rest)+ x:_ | isSpace x -> do+ rest <- lexRawPragma+ return $ OPTIONS (Nothing, rest)+ _ -> fail "Malformed Options pragma"+{- Just (CFILES _) -> do+ rest <- lexRawPragma+ return $ CFILES rest+ Just (INCLUDE _) -> do+ rest <- lexRawPragma+ return $ INCLUDE rest -}+ Just p -> return p++ _ -> fail "Internal error: Unrecognised recognised pragma"+ -- do rawStr <- lexRawPragma+ -- return $ PragmaUnknown (pr, rawStr) -- no support for unrecognized pragmas, treat as comment+ -- discard 3 -- #-}+ -- topLexer -- we just discard it as a comment for now and restart -}++lexRawPragma :: Lex a String+lexRawPragma = do+ rpr <- lexRawPragmaAux+ return $ dropWhile isSpace rpr+ where lexRawPragmaAux = do+ rpr <- lexWhile (/='#')+ s <- getInput+ case s of+ '#':'-':'}':_ -> return rpr+ "" -> fail "End-of-file inside pragma"+ _ -> do+ discard 1+ rpr' <- lexRawPragma+ return $ rpr ++ '#':rpr'++lexDecimalOrFloat :: Lex a Token+lexDecimalOrFloat = do+ ds <- lexWhile isDigit+ rest <- getInput+ exts <- getExtensionsL+ case rest of+ ('.':d:_) | isDigit d -> do+ discard 1+ frac <- lexWhile isDigit+ let num = parseInteger 10 (ds ++ frac)+ decimals = toInteger (length frac)+ (exponent, estr) <- do+ rest2 <- getInput+ case rest2 of+ 'e':_ -> lexExponent+ 'E':_ -> lexExponent+ _ -> return (0,"")+ con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash)+ return $ con ((num%1) * 10^^(exponent - decimals), ds ++ '.':frac ++ estr)+ e:_ | toLower e == 'e' -> do+ (exponent, estr) <- lexExponent+ con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash)+ return $ con ((parseInteger 10 ds%1) * 10^^exponent, ds ++ estr)+ '#':'#':_ | MagicHash `elem` exts -> discard 2 >> return (WordTokHash (parseInteger 10 ds, ds))+ '#':_ | MagicHash `elem` exts -> discard 1 >> return (IntTokHash (parseInteger 10 ds, ds))+ _ -> return (IntTok (parseInteger 10 ds, ds))++ where+ lexExponent :: Lex a (Integer, String)+ lexExponent = do+ (e:r) <- getInput+ discard 1 -- 'e' or 'E'+ case r of+ '+':d:_ | isDigit d -> do+ discard 1+ (n, str) <- lexDecimal+ return (n, e:'+':str)+ '-':d:_ | isDigit d -> do+ discard 1+ (n, str) <- lexDecimal+ return (negate n, e:'-':str)+ d:_ | isDigit d -> lexDecimal >>= \(n,str) -> return (n, e:str)+ _ -> fail "Float with missing exponent"++lexHash :: (b -> Token) -> (b -> Token) -> Either String (b -> Token) -> Lex a (b -> Token)+lexHash a b c = do+ exts <- getExtensionsL+ if MagicHash `elem` exts+ then do+ r <- getInput+ case r of+ '#':'#':_ -> case c of+ Right c -> discard 2 >> return c+ Left s -> fail s+ '#':_ -> discard 1 >> return b+ _ -> return a+ else return a++lexConIdOrQual :: String -> Lex a Token+lexConIdOrQual qual = do+ con <- lexWhile isIdent+ let conid | null qual = ConId con+ | otherwise = QConId (qual,con)+ qual' | null qual = con+ | otherwise = qual ++ '.':con+ just_a_conid <- alternative (return conid)+ rest <- getInput+ exts <- getExtensionsL+ case rest of+ '.':c:_+ | isLower c || c == '_' -> do -- qualified varid?+ discard 1+ ident <- lexWhile isIdent+ s <- getInput+ exts <- getExtensionsL+ ident' <- case s of+ '#':_ | MagicHash `elem` exts -> discard 1 >> return (ident ++ "#")+ _ -> return ident+ case lookup ident' reserved_ids of+ -- cannot qualify a reserved word+ Just (_,scheme) | isEnabled scheme exts -> just_a_conid+ _ -> return (QVarId (qual', ident'))++ | isUpper c -> do -- qualified conid?+ discard 1+ lexConIdOrQual qual'++ | isHSymbol c -> do -- qualified symbol?+ discard 1+ sym <- lexWhile isHSymbol+ exts <- getExtensionsL+ case lookup sym reserved_ops of+ -- cannot qualify a reserved operator+ Just (_,scheme) | isEnabled scheme exts -> just_a_conid+ _ -> return $ case c of+ ':' -> QConSym (qual', sym)+ _ -> QVarSym (qual', sym)++ '#':c:_+ | not (isHSymbol c) && not (isIdent c) && MagicHash `elem` exts -> do+ discard 1+ case conid of+ ConId con -> return $ ConId $ con ++ "#"+ QConId (q,con) -> return $ QConId (q,con ++ "#")+ _ -> return conid -- not a qualified thing++lexCharacter :: Lex a Token+lexCharacter = do -- We need to keep track of not only character constants but also TH 'x and ''T+ -- We've seen ' so far+ s <- getInput+ exts <- getExtensionsL+ case s of+ '\'':_ | TemplateHaskell `elem` exts -> discard 1 >> return THTyQuote+ '\\':_ -> do+ (c,raw) <- lexEscape+ matchQuote+ con <- lexHash Character CharacterHash+ (Left "Double hash not available for character literals")+ return (con (c, '\\':raw))+ c:'\'':_ -> do+ discard 2+ con <- lexHash Character CharacterHash+ (Left "Double hash not available for character literals")+ return (con (c, [c]))+ _ | TemplateHaskell `elem` exts -> return THVarQuote+ _ -> fail "Improper character constant or misplaced \'"++ where matchQuote = matchChar '\'' "Improperly terminated character constant"+++lexString :: Lex a Token+lexString = loop ("","")+ where+ loop (s,raw) = do+ r <- getInput+ exts <- getExtensionsL+ case r of+ '\\':'&':_ -> do+ discard 2+ loop (s, '&':'\\':raw)+ '\\':c:_ | isSpace c -> do+ discard 1+ wcs <- lexWhiteChars+ matchChar '\\' "Illegal character in string gap"+ loop (s, '\\':reverse wcs ++ '\\':raw)+ | otherwise -> do+ (ce, str) <- lexEscape+ loop (ce:s, reverse str ++ '\\':raw)+ '"':'#':_ | MagicHash `elem` exts -> do+ discard 2+ return (StringHash (reverse s, reverse raw))+ '"':_ -> do+ discard 1+ return (StringTok (reverse s, reverse raw))+ c:_ -> do+ discard 1+ loop (c:s, c:raw)+ [] -> fail "Improperly terminated string"++ lexWhiteChars :: Lex a String+ lexWhiteChars = do+ s <- getInput+ case s of+ '\n':_ -> do+ lexNewline+ wcs <- lexWhiteChars+ return $ '\n':wcs+ '\t':_ -> do+ lexTab+ wcs <- lexWhiteChars+ return $ '\t':wcs+ c:_ | isSpace c -> do+ discard 1+ wcs <- lexWhiteChars+ return $ c:wcs+ _ -> return ""++lexEscape :: Lex a (Char, String)+lexEscape = do+ discard 1+ r <- getInput+ case r of++-- Production charesc from section B.2 (Note: \& is handled by caller)++ 'a':_ -> discard 1 >> return ('\a', "a")+ 'b':_ -> discard 1 >> return ('\b', "b")+ 'f':_ -> discard 1 >> return ('\f', "f")+ 'n':_ -> discard 1 >> return ('\n', "n")+ 'r':_ -> discard 1 >> return ('\r', "r")+ 't':_ -> discard 1 >> return ('\t', "t")+ 'v':_ -> discard 1 >> return ('\v', "v")+ '\\':_ -> discard 1 >> return ('\\', "\\")+ '"':_ -> discard 1 >> return ('\"', "\"")+ '\'':_ -> discard 1 >> return ('\'', "\'")++-- Production ascii from section B.2++ '^':c:_ -> discard 2 >> cntrl c+ 'N':'U':'L':_ -> discard 3 >> return ('\NUL', "NUL")+ 'S':'O':'H':_ -> discard 3 >> return ('\SOH', "SOH")+ 'S':'T':'X':_ -> discard 3 >> return ('\STX', "STX")+ 'E':'T':'X':_ -> discard 3 >> return ('\ETX', "ETX")+ 'E':'O':'T':_ -> discard 3 >> return ('\EOT', "EOT")+ 'E':'N':'Q':_ -> discard 3 >> return ('\ENQ', "ENQ")+ 'A':'C':'K':_ -> discard 3 >> return ('\ACK', "ACK")+ 'B':'E':'L':_ -> discard 3 >> return ('\BEL', "BEL")+ 'B':'S':_ -> discard 2 >> return ('\BS', "BS")+ 'H':'T':_ -> discard 2 >> return ('\HT', "HT")+ 'L':'F':_ -> discard 2 >> return ('\LF', "LF")+ 'V':'T':_ -> discard 2 >> return ('\VT', "VT")+ 'F':'F':_ -> discard 2 >> return ('\FF', "FF")+ 'C':'R':_ -> discard 2 >> return ('\CR', "CR")+ 'S':'O':_ -> discard 2 >> return ('\SO', "SO")+ 'S':'I':_ -> discard 2 >> return ('\SI', "SI")+ 'D':'L':'E':_ -> discard 3 >> return ('\DLE', "DLE")+ 'D':'C':'1':_ -> discard 3 >> return ('\DC1', "DC1")+ 'D':'C':'2':_ -> discard 3 >> return ('\DC2', "DC2")+ 'D':'C':'3':_ -> discard 3 >> return ('\DC3', "DC3")+ 'D':'C':'4':_ -> discard 3 >> return ('\DC4', "DC4")+ 'N':'A':'K':_ -> discard 3 >> return ('\NAK', "NAK")+ 'S':'Y':'N':_ -> discard 3 >> return ('\SYN', "SYN")+ 'E':'T':'B':_ -> discard 3 >> return ('\ETB', "ETB")+ 'C':'A':'N':_ -> discard 3 >> return ('\CAN', "CAN")+ 'E':'M':_ -> discard 2 >> return ('\EM', "EM")+ 'S':'U':'B':_ -> discard 3 >> return ('\SUB', "SUB")+ 'E':'S':'C':_ -> discard 3 >> return ('\ESC', "ESC")+ 'F':'S':_ -> discard 2 >> return ('\FS', "FS")+ 'G':'S':_ -> discard 2 >> return ('\GS', "GS")+ 'R':'S':_ -> discard 2 >> return ('\RS', "RS")+ 'U':'S':_ -> discard 2 >> return ('\US', "US")+ 'S':'P':_ -> discard 2 >> return ('\SP', "SP")+ 'D':'E':'L':_ -> discard 3 >> return ('\DEL', "DEL")++-- Escaped numbers++ 'o':c:_ | isOctDigit c -> do+ discard 1+ (n, raw) <- lexOctal+ n <- checkChar n+ return (n, 'o':raw)+ 'x':c:_ | isHexDigit c -> do+ discard 1+ (n, raw) <- lexHexadecimal+ n <- checkChar n+ return (n, 'x':raw)+ c:_ | isDigit c -> do+ (n, raw) <- lexDecimal+ n <- checkChar n+ return (n, raw)++ _ -> fail "Illegal escape sequence"++ where+ checkChar n | n <= 0x01FFFF = return (chr (fromInteger n))+ checkChar _ = fail "Character constant out of range"++-- Production cntrl from section B.2++ cntrl :: Char -> Lex a (Char, String)+ cntrl c | c >= '@' && c <= '_' = return (chr (ord c - ord '@'), '^':c:[])+ cntrl _ = fail "Illegal control character"++-- assumes at least one octal digit+lexOctal :: Lex a (Integer, String)+lexOctal = do+ ds <- lexWhile isOctDigit+ return (parseInteger 8 ds, ds)++-- assumes at least one hexadecimal digit+lexHexadecimal :: Lex a (Integer, String)+lexHexadecimal = do+ ds <- lexWhile isHexDigit+ return (parseInteger 16 ds, ds)++-- assumes at least one decimal digit+lexDecimal :: Lex a (Integer, String)+lexDecimal = do+ ds <- lexWhile isDigit+ return (parseInteger 10 ds, ds)++-- Stolen from Hugs's Prelude+parseInteger :: Integer -> String -> Integer+parseInteger radix ds =+ foldl1 (\n d -> n * radix + d) (map (toInteger . digitToInt) ds)++flagKW :: Token -> Lex a ()+flagKW t = when (t `elem` [KW_Do, KW_MDo]) flagDo++------------------------------------------------------------------+-- "Pretty" printing for tokens++showToken :: Token -> String+showToken t = case t of+ VarId s -> s+ QVarId (q,s) -> q ++ '.':s+ IDupVarId s -> '?':s+ ILinVarId s -> '%':s+ ConId s -> s+ QConId (q,s) -> q ++ '.':s+ DVarId ss -> concat $ intersperse "-" ss+ VarSym s -> s+ ConSym s -> s+ QVarSym (q,s) -> q ++ '.':s+ QConSym (q,s) -> q ++ '.':s+ IntTok (_, s) -> s+ FloatTok (_, s) -> s+ Character (_, s) -> '\'':s ++ "'"+ StringTok (_, s) -> '"':s ++ "\""+ IntTokHash (_, s) -> s ++ "#"+ WordTokHash (_, s) -> s ++ "##"+ FloatTokHash (_, s) -> s ++ "#"+ DoubleTokHash (_, s) -> s ++ "##"+ CharacterHash (_, s) -> '\'':s ++ "'#"+ StringHash (_, s) -> '"':s ++ "\"#"+ LeftParen -> "("+ RightParen -> ")"+ LeftHashParen -> "(#"+ RightHashParen -> "#)"+ LeftCurlyBar -> "{|"+ RightCurlyBar -> "|}"+ SemiColon -> ";"+ LeftCurly -> "{"+ RightCurly -> "}"+ VRightCurly -> "virtual }"+ LeftSquare -> "["+ RightSquare -> "]"+ Comma -> ","+ DoubleUnderscore -> "__"+ Underscore -> "_"+ BackQuote -> "`"+ Dot -> "."+ DotDot -> ".."+ Colon -> ":"+ DoubleColon -> "::"+ Equals -> "="+ Backslash -> "\\"+ Bar -> "|"+ LeftArrow -> "<-"+ RightArrow -> "->"+ At -> "@"+ Tilde -> "~"+ DoubleArrow -> "=>"+ Minus -> "-"+ Exclamation -> "!"+ Star -> "*"+ LeftArrowTail -> ">-"+ RightArrowTail -> "-<"+ LeftDblArrowTail -> ">>-"+ RightDblArrowTail -> "-<<"+ THExpQuote -> "[|"+ THPatQuote -> "[p|"+ THDecQuote -> "[d|"+ THTypQuote -> "[t|"+ THCloseQuote -> "|]"+ THIdEscape s -> '$':s+ THParenEscape -> "$("+ THVarQuote -> "'"+ THTyQuote -> "''"+ THQuasiQuote (n,q) -> "[$" ++ n ++ "|" ++ q ++ "]"+ FSContextOpen -> "_["+ FSContextClose -> "]_"+--FSContextOpenClose -> "_[]_"+ RPGuardOpen -> "(|"+ RPGuardClose -> "|)"+ RPCAt -> "@:"+ XCodeTagOpen -> "<%"+ XCodeTagClose -> "%>"+ XStdTagOpen -> "<"+ XStdTagClose -> ">"+ XCloseTagOpen -> "</"+ XEmptyTagClose -> "/>"+ XPCDATA s -> "PCDATA " ++ s+ XRPatOpen -> "<["+ XRPatClose -> "]>"+ PragmaEnd -> "#-}"+ RULES -> "{-# RULES"+ INLINE b -> "{-# " ++ if b then "INLINE" else "NOINLINE"+ INLINE_CONLIKE -> "{-# " ++ "INLINE_CONLIKE"+ SPECIALISE -> "{-# SPECIALISE"+ SPECIALISE_INLINE b -> "{-# SPECIALISE " ++ if b then "INLINE" else "NOINLINE"+ SOURCE -> "{-# SOURCE"+ DEPRECATED -> "{-# DEPRECATED"+ WARNING -> "{-# WARNING"+ SCC -> "{-# SCC"+ GENERATED -> "{-# GENERATED"+ CORE -> "{-# CORE"+ UNPACK -> "{-# UNPACK"+ OPTIONS (mt,s) -> "{-# OPTIONS" ++ maybe "" (':':) mt ++ " ..."+-- CFILES s -> "{-# CFILES ..."+-- INCLUDE s -> "{-# INCLUDE ..."+ LANGUAGE -> "{-# LANGUAGE"+ ANN -> "{-# ANN"+ KW_As -> "as"+ KW_By -> "by"+ KW_Case -> "case"+ KW_Class -> "class"+ KW_Data -> "data"+ KW_Default -> "default"+ KW_Deriving -> "deriving"+ KW_Do -> "do"+ KW_MDo -> "mdo"+ KW_Else -> "else"+ KW_Family -> "family"+ KW_Forall -> "forall"+ KW_Group -> "group"+ KW_Hiding -> "hiding"+ KW_If -> "if"+ KW_Import -> "import"+ KW_In -> "in"+ KW_Infix -> "infix"+ KW_InfixL -> "infixl"+ KW_InfixR -> "infixr"+ KW_Instance -> "instance"+ KW_Let -> "let"+ KW_Module -> "module"+ KW_NewType -> "newtype"+ KW_Of -> "of"+ KW_Proc -> "proc"+ KW_Rec -> "rec"+ KW_Then -> "then"+ KW_Type -> "type"+ KW_Using -> "using"+ KW_Where -> "where"+ KW_Qualified -> "qualified"+ KW_Foreign -> "foreign"+ KW_Export -> "export"+ KW_Safe -> "safe"+ KW_Unsafe -> "unsafe"+ KW_Threadsafe -> "threadsafe"+ KW_StdCall -> "stdcall"+ KW_CCall -> "ccall"++ EOF -> "EOF"
+ HSE/ParseMonad.hs view
@@ -0,0 +1,428 @@+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Annotated.ParseMonad+-- Copyright : Niklas Broberg (c) 2004-2009,+-- Original (c) The GHC Team, 1997-2000+-- License : BSD-style (see the file libraries/base/LICENSE)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- Monads for the Haskell parser and lexer.+--+-----------------------------------------------------------------------------++module HSE.ParseMonad(+ -- * Parsing+ P, ParseResult(..), atSrcLoc, LexContext(..),+ ParseMode(..), defaultParseMode, fromParseResult,+ runParserWithMode, runParserWithModeComments, runParser,+ getSrcLoc, pushCurrentContext, popContext,+ getExtensions,+ -- * Lexing+ Lex(runL), getInput, discard, lexNewline, lexTab, lexWhile,+ alternative, checkBOL, setBOL, startToken, getOffside,+ pushContextL, popContextL, getExtensionsL, pushComment, + getSrcLocL, setSrcLineL, ignoreLinePragmasL, setLineFilenameL,+ -- * Harp/Hsx+ ExtContext(..),+ pushExtContextL, popExtContextL, getExtContext,+ pullCtxtFlag, flagDo,+ getModuleName+ ) where++import HSE.SrcLoc(SrcLoc(..))+import HSE.Fixity (Fixity, preludeFixities)+import HSE.Comments+import HSE.Extension (Extension, impliesExts)++import Data.List ( intersperse )+import Control.Applicative+import Control.Monad (when)+import Data.Monoid++-- | The result of a parse.+data ParseResult a+ = ParseOk a -- ^ The parse succeeded, yielding a value.+ | ParseFailed SrcLoc String+ -- ^ The parse failed at the specified+ -- source location, with an error message.+ deriving Show++-- | Retrieve the result of a successful parse, throwing an+-- error if the parse is actually not successful.+fromParseResult :: ParseResult a -> a+fromParseResult (ParseOk a) = a+fromParseResult (ParseFailed loc str) = error $ "fromParseResult: Parse failed at ["+ ++ srcFilename loc ++ "] (" ++ show (srcLine loc) ++ ":" ++ show (srcColumn loc) ++ "): " ++ str++instance Functor ParseResult where+ fmap f (ParseOk x) = ParseOk $ f x+ fmap f (ParseFailed loc msg) = ParseFailed loc msg++instance Applicative ParseResult where+ pure = ParseOk+ ParseOk f <*> x = f <$> x+ ParseFailed loc msg <*> _ = ParseFailed loc msg++instance Monad ParseResult where+ return = ParseOk+ ParseOk x >>= f = f x+ ParseFailed loc msg >>= _ = ParseFailed loc msg++instance Monoid m => Monoid (ParseResult m) where+ mempty = ParseOk mempty+ ParseOk x `mappend` ParseOk y = ParseOk $ x `mappend` y+ ParseOk x `mappend` err = err+ err `mappend` _ = err -- left-biased+++-- internal version+data ParseStatus a = Ok ParseState a | Failed SrcLoc String+ deriving Show++data LexContext = NoLayout | Layout Int+ deriving (Eq,Ord,Show)++data ExtContext = CodeCtxt | HarpCtxt | TagCtxt | ChildCtxt+ | CloseTagCtxt | CodeTagCtxt+ deriving (Eq,Ord,Show)++type CtxtFlag = (Bool,Bool)+-- (True,_) = We're in a do context.+-- (_, True)= Next token must be a virtual closing brace.++type ParseState = ([LexContext],[ExtContext],CtxtFlag,[Comment])++indentOfParseState :: ParseState -> Int+indentOfParseState (Layout n:_,_,_,_) = n+indentOfParseState _ = 0++-- | Static parameters governing a parse.+-- Note that the various parse functions in "HSE.Parser"+-- never look at LANGUAGE pragmas, regardless of+-- what the @ignoreLanguagePragmas@ flag is set to.+-- Only the various @parseFile@ functions in "HSE" will+-- act on it, when set to 'False'.++data ParseMode = ParseMode {+ -- | original name of the file being parsed+ parseFilename :: String,+ -- | list of extensions enabled for parsing+ extensions :: [Extension],+ -- | if 'True', the parser won't care about further extensions+ -- in LANGUAGE pragmas in source files+ ignoreLanguagePragmas :: Bool,+ -- | if 'True', the parser won't read line position information+ -- from LINE pragmas in source files+ ignoreLinePragmas :: Bool,+ -- | list of fixities to be aware of+ fixities :: Maybe [Fixity]+ }++-- | Default parameters for a parse.+-- The default is an unknown filename,+-- no extensions (i.e. Haskell 98),+-- don't ignore LANGUAGE pragmas, do ignore LINE pragmas,+-- and be aware of fixities from the 'Prelude'.+defaultParseMode :: ParseMode+defaultParseMode = ParseMode {+ parseFilename = "<unknown>.hs",+ extensions = [],+ ignoreLanguagePragmas = False,+ ignoreLinePragmas = True,+ fixities = Just preludeFixities+ }++-- | Monad for parsing++newtype P a = P { runP ::+ String -- input string+ -> Int -- current column+ -> Int -- current line+ -> SrcLoc -- location of last token read+ -> ParseState -- layout info.+ -> ParseMode -- parse parameters+ -> ParseStatus a+ }++runParserWithMode :: ParseMode -> P a -> String -> ParseResult a+{-runParserWithMode mode (P m) s = case m s 0 1 start ([],[],(False,False),[]) mode of+ Ok _ a -> ParseOk a+ Failed loc msg -> ParseFailed loc msg+ where start = SrcLoc {+ srcFilename = parseFilename mode,+ srcLine = 1,+ srcColumn = 1+ }+-}+runParserWithMode mode pm s = fmap fst $ runParserWithModeComments mode pm s++runParser :: P a -> String -> ParseResult a+runParser = runParserWithMode defaultParseMode++runParserWithModeComments :: ParseMode -> P a -> String -> ParseResult (a, [Comment])+runParserWithModeComments mode (P m) s = case m s 0 1 start ([],[],(False,False),[]) (allExts mode) of+ Ok (_,_,_,cs) a -> ParseOk (a, reverse cs)+ Failed loc msg -> ParseFailed loc msg+ where start = SrcLoc {+ srcFilename = parseFilename mode,+ srcLine = 1,+ srcColumn = 1+ }+ allExts mode@(ParseMode {extensions = es}) = mode { extensions = impliesExts es }++instance Monad P where+ return a = P $ \_i _x _y _l s _m -> Ok s a+ P m >>= k = P $ \i x y l s mode ->+ case m i x y l s mode of+ Failed loc msg -> Failed loc msg+ Ok s' a -> runP (k a) i x y l s' mode+ fail s = P $ \_r _col _line loc _stk _m -> Failed loc s++atSrcLoc :: P a -> SrcLoc -> P a+P m `atSrcLoc` loc = P $ \i x y _l -> m i x y loc++getSrcLoc :: P SrcLoc+getSrcLoc = P $ \_i _x _y l s _m -> Ok s l++getModuleName :: P String+getModuleName = P $ \_i _x _y _l s m ->+ let fn = parseFilename m+ mn = concat $ intersperse "." $ splitPath fn++ splitPath :: String -> [String]+ splitPath "" = []+ splitPath str = let (l,str') = break ('\\'==) str+ in case str' of+ [] -> [removeSuffix l]+ (_:str'') -> l : splitPath str''++ removeSuffix l = reverse $ tail $ dropWhile ('.'/=) $ reverse l++ in Ok s mn++-- Enter a new layout context. If we are already in a layout context,+-- ensure that the new indent is greater than the indent of that context.+-- (So if the source loc is not to the right of the current indent, an+-- empty list {} will be inserted.)++pushCurrentContext :: P ()+pushCurrentContext = do+ lc <- getSrcLoc+ indent <- currentIndent+ dob <- pullDoStatus+ let loc = srcColumn lc+ when (dob && loc < indent+ || not dob && loc <= indent) $ pushCtxtFlag+ pushContext (Layout loc)++currentIndent :: P Int+currentIndent = P $ \_r _x _y loc stk _mode -> Ok stk (indentOfParseState stk)++pushContext :: LexContext -> P ()+pushContext ctxt =+--trace ("pushing lexical scope: " ++ show ctxt ++"\n") $+ P $ \_i _x _y _l (s, e, p, c) _m -> Ok (ctxt:s, e, p, c) ()++popContext :: P ()+popContext = P $ \_i _x _y _l stk _m ->+ case stk of+ (_:s, e, p, c) -> --trace ("popping lexical scope, context now "++show s ++ "\n") $+ Ok (s, e, p, c) ()+ ([],_,_,_) -> error "Internal error: empty context in popContext"+++-- HaRP/Hsx+pushExtContext :: ExtContext -> P ()+pushExtContext ctxt = P $ \_i _x _y _l (s, e, p, c) _m -> Ok (s, ctxt:e, p, c) ()++popExtContext :: P ()+popExtContext = P $ \_i _x _y _l (s, e, p, c) _m ->+ case e of+ (_:e') ->+ Ok (s, e', p, c) ()+ [] -> error "Internal error: empty context in popExtContext"+++-- Extension-aware lexing/parsing+getExtensions :: P [Extension]+getExtensions = P $ \_i _x _y _l s m ->+ Ok s $ extensions m++pushCtxtFlag :: P ()+pushCtxtFlag =+ P $ \_i _x _y _l (s, e, (d,c), cs) _m -> case c of+ False -> Ok (s, e, (d,True), cs) ()+ _ -> error "Internal error: context flag already pushed"++pullDoStatus :: P Bool+pullDoStatus = P $ \_i _x _y _l (s, e, (d,c), cs) _m -> Ok (s,e,(False,c),cs) d+++----------------------------------------------------------------------------+-- Monad for lexical analysis:+-- a continuation-passing version of the parsing monad++newtype Lex r a = Lex { runL :: (a -> P r) -> P r }++instance Monad (Lex r) where+ return a = Lex $ \k -> k a+ Lex v >>= f = Lex $ \k -> v (\a -> runL (f a) k)+ Lex v >> Lex w = Lex $ \k -> v (\_ -> w k)+ fail s = Lex $ \_ -> fail s++-- Operations on this monad++getInput :: Lex r String+getInput = Lex $ \cont -> P $ \r -> runP (cont r) r++-- | Discard some input characters (these must not include tabs or newlines).++discard :: Int -> Lex r ()+discard n = Lex $ \cont -> P $ \r x -> runP (cont ()) (drop n r) (x+n)++-- | Discard the next character, which must be a newline.++lexNewline :: Lex a ()+lexNewline = Lex $ \cont -> P $ \(_:r) _x y -> runP (cont ()) r 1 (y+1)++-- | Discard the next character, which must be a tab.++lexTab :: Lex a ()+lexTab = Lex $ \cont -> P $ \(_:r) x -> runP (cont ()) r (nextTab x)++nextTab :: Int -> Int+nextTab x = x + (tAB_LENGTH - (x-1) `mod` tAB_LENGTH)++tAB_LENGTH :: Int+tAB_LENGTH = 8 :: Int++-- Consume and return the largest string of characters satisfying p++lexWhile :: (Char -> Bool) -> Lex a String+lexWhile p = Lex $ \cont -> P $ \r x ->+ let (cs,rest) = span p r in+ runP (cont cs) rest (x + length cs)++-- An alternative scan, to which we can return if subsequent scanning+-- is unsuccessful.++alternative :: Lex a v -> Lex a (Lex a v)+alternative (Lex v) = Lex $ \cont -> P $ \r x y ->+ runP (cont (Lex $ \cont' -> P $ \_r _x _y ->+ runP (v cont') r x y)) r x y++-- The source location is the coordinates of the previous token,+-- or, while scanning a token, the start of the current token.++-- col is the current column in the source file.+-- We also need to remember between scanning tokens whether we are+-- somewhere at the beginning of the line before the first token.+-- This could be done with an extra Bool argument to the P monad,+-- but as a hack we use a col value of 0 to indicate this situation.++-- Setting col to 0 is used in two places: just after emitting a virtual+-- close brace due to layout, so that next time through we check whether+-- we also need to emit a semi-colon, and at the beginning of the file,+-- by runParser, to kick off the lexer.+-- Thus when col is zero, the true column can be taken from the loc.++checkBOL :: Lex a Bool+checkBOL = Lex $ \cont -> P $ \r x y loc ->+ if x == 0 then runP (cont True) r (srcColumn loc) y loc+ else runP (cont False) r x y loc++setBOL :: Lex a ()+setBOL = Lex $ \cont -> P $ \r _ -> runP (cont ()) r 0++-- Set the loc to the current position++startToken :: Lex a ()+startToken = Lex $ \cont -> P $ \s x y _ stk mode ->+ let loc = SrcLoc {+ srcFilename = parseFilename mode,+ srcLine = y,+ srcColumn = x+ } in+ runP (cont ()) s x y loc stk mode++-- Current status with respect to the offside (layout) rule:+-- LT: we are to the left of the current indent (if any)+-- EQ: we are at the current indent (if any)+-- GT: we are to the right of the current indent, or not subject to layout++getOffside :: Lex a Ordering+getOffside = Lex $ \cont -> P $ \r x y loc stk ->+ runP (cont (compare x (indentOfParseState stk))) r x y loc stk++getSrcLocL :: Lex a SrcLoc+getSrcLocL = Lex $ \cont -> P $ \i x y l ->+ runP (cont (l { srcLine = y, srcColumn = x })) i x y l++setSrcLineL :: Int -> Lex a ()+setSrcLineL y = Lex $ \cont -> P $ \i x _ ->+ runP (cont ()) i x y++pushContextL :: LexContext -> Lex a ()+pushContextL ctxt = Lex $ \cont -> P $ \r x y loc (stk, e, pst, cs) ->+ runP (cont ()) r x y loc (ctxt:stk, e, pst, cs)++popContextL :: String -> Lex a ()+popContextL fn = Lex $ \cont -> P $ \r x y loc stk -> case stk of+ (_:ctxt, e, pst, cs) -> runP (cont ()) r x y loc (ctxt, e, pst, cs)+ ([], _, _, _) -> error ("Internal error: empty context in " ++ fn)++pullCtxtFlag :: Lex a Bool+pullCtxtFlag = Lex $ \cont -> P $ \r x y loc (ct, e, (d,c), cs) ->+ runP (cont c) r x y loc (ct, e, (d,False), cs)+++flagDo :: Lex a ()+flagDo = Lex $ \cont -> P $ \r x y loc (ct, e, (d,c), cs) ->+ runP (cont ()) r x y loc (ct, e, (True,c), cs)+++-- Harp/Hsx++getExtContext :: Lex a (Maybe ExtContext)+getExtContext = Lex $ \cont -> P $ \r x y loc stk@(_, e, _, _) ->+ let me = case e of+ [] -> Nothing+ (c:_) -> Just c+ in runP (cont me) r x y loc stk++pushExtContextL :: ExtContext -> Lex a ()+pushExtContextL ec = Lex $ \cont -> P $ \r x y loc (s, e, p, c) ->+ runP (cont ()) r x y loc (s, ec:e, p, c)++popExtContextL :: String -> Lex a ()+popExtContextL fn = Lex $ \cont -> P $ \r x y loc stk@(s,e,p,c) -> case e of+ (_:ec) -> runP (cont ()) r x y loc (s,ec,p,c)+ [] -> error ("Internal error: empty tag context in " ++ fn)+++-- Extension-aware lexing++getExtensionsL :: Lex a [Extension]+getExtensionsL = Lex $ \cont -> P $ \r x y loc s m ->+ runP (cont $ extensions m) r x y loc s m++-- LINE-aware lexing++ignoreLinePragmasL :: Lex a Bool+ignoreLinePragmasL = Lex $ \cont -> P $ \r x y loc s m ->+ runP (cont $ ignoreLinePragmas m) r x y loc s m++-- If we read a file name in a LINE pragma, we should update the state.+setLineFilenameL :: String -> Lex a ()+setLineFilenameL name = Lex $ \cont -> P $ \r x y loc s m ->+ runP (cont ()) r x y loc s (m {parseFilename = name})+ +-- Comments++pushComment :: Comment -> Lex a ()+pushComment c = Lex $ \cont -> P $ \r x y loc (s, e, p, cs) ->+ runP (cont ()) r x y loc (s, e, p, c:cs)
+ HSE/ParseSyntax.hs view
@@ -0,0 +1,448 @@+{-# OPTIONS_HADDOCK hide #-} +module HSE.ParseSyntax where + +import HSE.Annotated.Syntax hiding ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) ) +import qualified HSE.Annotated.Syntax as S ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) ) + +--------------------------------------- +-- Expressions as we parse them (and patters, and regular patterns) + +data PExp l + = Var l (QName l) -- ^ variable + | IPVar l (IPName l) -- ^ implicit parameter variable + | Con l (QName l) -- ^ data constructor + | Lit l (Literal l) -- ^ literal constant + | InfixApp l (PExp l) (QOp l) (PExp l) -- ^ infix application + | App l (PExp l) (PExp l) -- ^ ordinary application + | NegApp l (PExp l) -- ^ negation expression @-@ /exp/ + | Lambda l [Pat l] (PExp l) -- ^ lambda expression + | Let l (Binds l) (PExp l) -- ^ local declarations with @let@ + | If l (PExp l) (PExp l) (PExp l) -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ + | Case l (PExp l) [Alt l] -- ^ @case@ /exp/ @of@ /alts/ + | Do l [Stmt l] -- ^ @do@-expression: + -- the last statement in the list + -- should be an expression. + | MDo l [Stmt l] -- ^ @mdo@-expression +-- | Tuple [PExp] -- ^ tuple expression + | TupleSection l [Maybe (PExp l)] -- ^ tuple section expression, e.g. @(,,3)@ + | List l [PExp l] -- ^ list expression + | FSContext l (PExp l) -- ^ FreeSect context + | Paren l (PExp l) -- ^ parenthesized expression +-- RightSection QOp PExp -- ^ right section @(@/qop/ /exp/@)@ + | RecConstr l (QName l) [PFieldUpdate l] + -- ^ record construction expression + | RecUpdate l (PExp l) [PFieldUpdate l] + -- ^ record update expression + | EnumFrom l (PExp l) -- ^ unbounded arithmetic sequence, + -- incrementing by 1 + | EnumFromTo l (PExp l) (PExp l) -- ^ bounded arithmetic sequence, + -- incrementing by 1 + | EnumFromThen l (PExp l) (PExp l) -- ^ unbounded arithmetic sequence, + -- with first two elements given + | EnumFromThenTo l (PExp l) (PExp l) (PExp l) + -- ^ bounded arithmetic sequence, + -- with first two elements given + | ParComp l (PExp l) [[QualStmt l]] -- ^ parallel list comprehension + | ExpTypeSig l (PExp l) (S.Type l) -- ^ expression type signature + | AsPat l (Name l) (PExp l) -- ^ patterns only + | FreeSectSlot l -- ^ expressions only + | WildCard l -- ^ patterns only + | IrrPat l (PExp l) -- ^ patterns only + +-- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree. + | PostOp l (PExp l) (QOp l) -- ^ post-ops + | PreOp l (QOp l) (PExp l) -- ^ pre-ops + +-- View patterns + | ViewPat l (PExp l) (PExp l) -- ^ patterns only + +-- HaRP + | SeqRP l [PExp l] -- ^ regular patterns only + | GuardRP l (PExp l) [Stmt l] -- ^ regular patterns only + | EitherRP l (PExp l) (PExp l) -- ^ regular patterns only + | CAsRP l (Name l) (PExp l) -- ^ regular patterns only + +-- Template Haskell + | VarQuote l (QName l) -- ^ 'x + | TypQuote l (QName l) -- ^ ''T + | BracketExp l (Bracket l) + | SpliceExp l (Splice l) + | QuasiQuote l String String -- ^ [$...|...] + +-- Hsx + | XTag l (XName l) [ParseXAttr l] (Maybe (PExp l)) [PExp l] + -- ^ <Name>...</Name> + | XETag l (XName l) [ParseXAttr l] (Maybe (PExp l)) + -- ^ <Name /> + | XPcdata l String -- ^ PCDATA + | XExpTag l (PExp l) -- ^ <% ... %> + | XChildTag l [PExp l] -- ^ <%> ... </%> + | XRPats l [PExp l] -- ^ <[ ... ]> + +-- Pragmas + | CorePragma l String (PExp l) -- ^ {-# CORE #-} pragma + | SCCPragma l String (PExp l) -- ^ {-# SCC #-} pragma + | GenPragma l String (Int, Int) (Int, Int) (PExp l) + -- ^ {-# GENERATED ... #-} pragma + +-- Generics + | ExplTypeArg l (QName l) (S.Type l) -- ^ f {| Int |} x = ... + +-- Bang Patterns + | BangPat l (PExp l) -- ^ f !a = ... + +-- Arrows + | Proc l (Pat l) (PExp l) -- ^ proc p -> do + | LeftArrApp l (PExp l) (PExp l) -- ^ e -< e + | RightArrApp l (PExp l) (PExp l) -- ^ e >- e + | LeftArrHighApp l (PExp l) (PExp l) -- ^ e -<< e + | RightArrHighApp l (PExp l) (PExp l) -- ^ e >>- e + deriving (Eq,Show) + +data PFieldUpdate l + = FieldUpdate l (QName l) (PExp l) + | FieldPun l (Name l) + | FieldWildcard l + deriving (Eq,Show) + +data ParseXAttr l = XAttr l (XName l) (PExp l) + deriving (Eq,Show) + +instance Annotated PExp where + ann e = case e of + Var l qn -> l + IPVar l ipn -> l + Con l qn -> l + Lit l lit -> l + InfixApp l e1 qop e2 -> l + App l e1 e2 -> l + NegApp l e -> l + Lambda l ps e -> l + Let l bs e -> l + If l ec et ee -> l + Case l e alts -> l + Do l ss -> l + MDo l ss -> l + TupleSection l mes -> l + List l es -> l + FSContext l e -> l + Paren l e -> l + RecConstr l qn fups -> l + RecUpdate l e fups -> l + EnumFrom l e -> l + EnumFromTo l ef et -> l + EnumFromThen l ef et -> l + EnumFromThenTo l ef eth eto -> l + ParComp l e qsss -> l + ExpTypeSig l e t -> l + AsPat l n e -> l + FreeSectSlot l -> l + WildCard l -> l + IrrPat l e -> l + PostOp l e op -> l + PreOp l op e -> l + ViewPat l e1 e2 -> l + SeqRP l es -> l + GuardRP l e ss -> l + EitherRP l e1 e2 -> l + CAsRP l n e -> l + + VarQuote l qn -> l + TypQuote l qn -> l + BracketExp l br -> l + SpliceExp l sp -> l + QuasiQuote l sn se -> l + + XTag l xn xas me es -> l + XETag l xn xas me -> l + XPcdata l s -> l + XExpTag l e -> l + XChildTag l es -> l + XRPats l es -> l + + CorePragma l s e -> l + SCCPragma l s e -> l + GenPragma l s n12 n34 e -> l + + ExplTypeArg l qn t -> l + BangPat l e -> l + + Proc l p e -> l + LeftArrApp l e1 e2 -> l + RightArrApp l e1 e2 -> l + LeftArrHighApp l e1 e2 -> l + RightArrHighApp l e1 e2 -> l + + amap f e = case e of + Var l qn -> Var (f l) qn + IPVar l ipn -> IPVar (f l) ipn + Con l qn -> Con (f l) qn + Lit l lit -> Lit (f l) lit + InfixApp l e1 qop e2 -> InfixApp (f l) e1 qop e2 + App l e1 e2 -> App (f l) e1 e2 + NegApp l e -> NegApp (f l) e + Lambda l ps e -> Lambda (f l) ps e + Let l bs e -> Let (f l) bs e + If l ec et ee -> If (f l) ec et ee + Case l e alts -> Case (f l) e alts + Do l ss -> Do (f l) ss + MDo l ss -> MDo (f l) ss + TupleSection l mes -> TupleSection (f l) mes + List l es -> List (f l) es + FSContext l e -> FSContext (f l) e + Paren l e -> Paren (f l) e + RecConstr l qn fups -> RecConstr (f l) qn fups + RecUpdate l e fups -> RecUpdate (f l) e fups + EnumFrom l e -> EnumFrom (f l) e + EnumFromTo l ef et -> EnumFromTo (f l) ef et + EnumFromThen l ef et -> EnumFromThen (f l) ef et + EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) ef eth eto + ParComp l e qsss -> ParComp (f l) e qsss + ExpTypeSig l e t -> ExpTypeSig (f l) e t + + AsPat l n e -> AsPat (f l) n e + FreeSectSlot l -> FreeSectSlot (f l) + WildCard l -> WildCard (f l) + IrrPat l e -> IrrPat (f l) e + PostOp l e op -> PostOp (f l) e op + PreOp l op e -> PreOp (f l) op e + ViewPat l e1 e2 -> ViewPat (f l) e1 e2 + SeqRP l es -> SeqRP (f l) es + GuardRP l e ss -> GuardRP (f l) e ss + EitherRP l e1 e2 -> EitherRP (f l) e1 e2 + CAsRP l n e -> CAsRP (f l) n e + ExplTypeArg l n t -> ExplTypeArg (f l) n t + BangPat l e -> BangPat (f l) e + + VarQuote l qn -> VarQuote (f l) qn + TypQuote l qn -> TypQuote (f l) qn + BracketExp l br -> BracketExp (f l) br + SpliceExp l sp -> SpliceExp (f l) sp + QuasiQuote l sn se -> QuasiQuote (f l) sn se + + XTag l xn xas me es -> XTag (f l) xn xas me es + XETag l xn xas me -> XETag (f l) xn xas me + XPcdata l s -> XPcdata (f l) s + XExpTag l e -> XExpTag (f l) e + XChildTag l es -> XChildTag (f l) es + XRPats l es -> XRPats (f l) es + + CorePragma l s e -> CorePragma (f l) s e + SCCPragma l s e -> SCCPragma (f l) s e + GenPragma l s n12 n34 e -> GenPragma (f l) s n12 n34 e + + Proc l p e -> Proc (f l) p e + LeftArrApp l e1 e2 -> LeftArrApp (f l) e1 e2 + RightArrApp l e1 e2 -> RightArrApp (f l) e1 e2 + LeftArrHighApp l e1 e2 -> LeftArrHighApp (f l) e1 e2 + RightArrHighApp l e1 e2 -> RightArrHighApp (f l) e1 e2 + +instance Functor PExp where + fmap f e = case e of + Var l qn -> Var (f l) (fmap f qn) + IPVar l ipn -> IPVar (f l) (fmap f ipn) + Con l qn -> Con (f l) (fmap f qn) + Lit l lit -> Lit (f l) (fmap f lit) + InfixApp l e1 qop e2 -> InfixApp (f l) (fmap f e1) (fmap f qop) (fmap f e2) + App l e1 e2 -> App (f l) (fmap f e1) (fmap f e2) + NegApp l e -> NegApp (f l) (fmap f e) + Lambda l ps e -> Lambda (f l) (map (fmap f) ps) (fmap f e) + Let l bs e -> Let (f l) (fmap f bs) (fmap f e) + If l ec et ee -> If (f l) (fmap f ec) (fmap f et) (fmap f ee) + Case l e alts -> Case (f l) (fmap f e) (map (fmap f) alts) + Do l ss -> Do (f l) (map (fmap f) ss) + MDo l ss -> MDo (f l) (map (fmap f) ss) + TupleSection l mes -> TupleSection (f l) (map (fmap (fmap f)) mes) + List l es -> List (f l) (map (fmap f) es) + FSContext l e -> FSContext (f l) (fmap f e) + Paren l e -> Paren (f l) (fmap f e) + RecConstr l qn fups -> RecConstr (f l) (fmap f qn) (map (fmap f) fups) + RecUpdate l e fups -> RecUpdate (f l) (fmap f e) (map (fmap f) fups) + EnumFrom l e -> EnumFrom (f l) (fmap f e) + EnumFromTo l ef et -> EnumFromTo (f l) (fmap f ef) (fmap f et) + EnumFromThen l ef et -> EnumFromThen (f l) (fmap f ef) (fmap f et) + EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) (fmap f ef) (fmap f eth) (fmap f eto) + ParComp l e qsss -> ParComp (f l) (fmap f e) (map (map (fmap f)) qsss) + ExpTypeSig l e t -> ExpTypeSig (f l) (fmap f e) (fmap f t) + + AsPat l n e -> AsPat (f l) (fmap f n) (fmap f e) + FreeSectSlot l -> FreeSectSlot (f l) + WildCard l -> WildCard (f l) + IrrPat l e -> IrrPat (f l) (fmap f e) + PostOp l e op -> PostOp (f l) (fmap f e) (fmap f op) + PreOp l op e -> PreOp (f l) (fmap f op) (fmap f e) + ViewPat l e1 e2 -> ViewPat (f l) (fmap f e1) (fmap f e2) + SeqRP l es -> SeqRP (f l) (map (fmap f) es) + GuardRP l e ss -> GuardRP (f l) (fmap f e) (map (fmap f) ss) + EitherRP l e1 e2 -> EitherRP (f l) (fmap f e1) (fmap f e2) + CAsRP l n e -> CAsRP (f l) (fmap f n) (fmap f e) + ExplTypeArg l n t -> ExplTypeArg (f l) (fmap f n) (fmap f t) + BangPat l e -> BangPat (f l) (fmap f e) + + VarQuote l qn -> VarQuote (f l) (fmap f qn) + TypQuote l qn -> TypQuote (f l) (fmap f qn) + BracketExp l br -> BracketExp (f l) (fmap f br) + SpliceExp l sp -> SpliceExp (f l) (fmap f sp) + QuasiQuote l sn se -> QuasiQuote (f l) sn se + + XTag l xn xas me es -> XTag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es) + XETag l xn xas me -> XETag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) + XPcdata l s -> XPcdata (f l) s + XExpTag l e -> XExpTag (f l) (fmap f e) + XChildTag l es -> XChildTag (f l) (map (fmap f) es) + XRPats l es -> XRPats (f l) (map (fmap f) es) + + CorePragma l s e -> CorePragma (f l) s (fmap f e) + SCCPragma l s e -> SCCPragma (f l) s (fmap f e) + GenPragma l s n12 n34 e -> GenPragma (f l) s n12 n34 (fmap f e) + + Proc l p e -> Proc (f l) (fmap f p) (fmap f e) + LeftArrApp l e1 e2 -> LeftArrApp (f l) (fmap f e1) (fmap f e2) + RightArrApp l e1 e2 -> RightArrApp (f l) (fmap f e1) (fmap f e2) + LeftArrHighApp l e1 e2 -> LeftArrHighApp (f l) (fmap f e1) (fmap f e2) + RightArrHighApp l e1 e2 -> RightArrHighApp (f l) (fmap f e1) (fmap f e2) + + + +instance Functor PFieldUpdate where + fmap f (FieldUpdate l qn e) = FieldUpdate (f l) (fmap f qn) (fmap f e) + fmap f (FieldPun l n) = FieldPun (f l) (fmap f n) + fmap f (FieldWildcard l) = FieldWildcard (f l) + +instance Annotated PFieldUpdate where + ann (FieldUpdate l qn e) = l + ann (FieldPun l n) = l + ann (FieldWildcard l) = l + amap f (FieldUpdate l qn e) = FieldUpdate (f l) qn e + amap f (FieldPun l n) = FieldPun (f l) n + amap f (FieldWildcard l) = FieldWildcard (f l) + +instance Functor ParseXAttr where + fmap f (XAttr l xn e) = XAttr (f l) (fmap f xn) (fmap f e) + +instance Annotated ParseXAttr where + ann (XAttr l _ _) = l + amap f (XAttr l xn e) = XAttr (f l) xn e + +p_unit_con :: l -> PExp l +p_unit_con l = Con l (unit_con_name l) + +p_tuple_con :: l -> Boxed -> Int -> PExp l +p_tuple_con l b i = Con l (tuple_con_name l b i) + +p_unboxed_singleton_con :: l -> PExp l +p_unboxed_singleton_con l = Con l (unboxed_singleton_con_name l) + +data PContext l + = CxSingle l (PAsst l) + | CxTuple l [PAsst l] + | CxParen l (PContext l) + | CxEmpty l + deriving (Eq, Show) + +instance Functor PContext where + fmap f (CxSingle l asst) = CxSingle (f l) (fmap f asst) + fmap f (CxTuple l assts) = CxTuple (f l) (map (fmap f) assts) + fmap f (CxParen l ctxt) = CxParen (f l) (fmap f ctxt) + fmap f (CxEmpty l) = CxEmpty (f l) + +instance Annotated PContext where + ann (CxSingle l asst ) = l + ann (CxTuple l assts) = l + ann (CxParen l ctxt ) = l + ann (CxEmpty l) = l + amap f (CxSingle l asst ) = CxSingle (f l) asst + amap f (CxTuple l assts) = CxTuple (f l) assts + amap f (CxParen l ctxt ) = CxParen (f l) ctxt + amap f (CxEmpty l) = CxEmpty (f l) + +data PType l + = TyForall l + (Maybe [TyVarBind l]) + (Maybe (PContext l)) + (PType l) + | TyFun l (PType l) (PType l) -- ^ function type + | TyTuple l Boxed [PType l] -- ^ tuple type, possibly boxed + | TyList l (PType l) -- ^ list syntax, e.g. [a], as opposed to [] a + | TyApp l (PType l) (PType l) -- ^ application of a type constructor + | TyVar l (Name l) -- ^ type variable + | TyCon l (QName l) -- ^ named type or type constructor + | TyParen l (PType l) -- ^ type surrounded by parentheses + | TyPred l (PAsst l) -- ^ assertion of an implicit parameter + | TyInfix l (PType l) (QName l) (PType l) -- ^ infix type constructor + | TyKind l (PType l) (Kind l) -- ^ type with explicit kind signature + deriving (Eq, Show) + +instance Functor PType where + fmap f t = case t of + TyForall l mtvs mcx t -> TyForall (f l) (fmap (map (fmap f)) mtvs) (fmap (fmap f) mcx) (fmap f t) + TyFun l t1 t2 -> TyFun (f l) (fmap f t1) (fmap f t2) + TyTuple l b ts -> TyTuple (f l) b (map (fmap f) ts) + TyList l t -> TyList (f l) (fmap f t) + TyApp l t1 t2 -> TyApp (f l) (fmap f t1) (fmap f t2) + TyVar l n -> TyVar (f l) (fmap f n) + TyCon l qn -> TyCon (f l) (fmap f qn) + TyParen l t -> TyParen (f l) (fmap f t) + TyPred l asst -> TyPred (f l) (fmap f asst) + TyInfix l ta qn tb -> TyInfix (f l) (fmap f ta) (fmap f qn) (fmap f tb) + TyKind l t k -> TyKind (f l) (fmap f t) (fmap f k) + +instance Annotated PType where + ann t = case t of + TyForall l mtvs cx t -> l + TyFun l t1 t2 -> l + TyTuple l b ts -> l + TyList l t -> l + TyApp l t1 t2 -> l + TyVar l n -> l + TyCon l qn -> l + TyParen l t -> l + TyInfix l ta qn tb -> l + TyKind l t k -> l + amap f t = case t of + TyForall l mtvs mcx t -> TyForall (f l) mtvs mcx t + TyFun l t1 t2 -> TyFun (f l) t1 t2 + TyTuple l b ts -> TyTuple (f l) b ts + TyList l t -> TyList (f l) t + TyApp l t1 t2 -> TyApp (f l) t1 t2 + TyVar l n -> TyVar (f l) n + TyCon l qn -> TyCon (f l) qn + TyParen l t -> TyParen (f l) t + TyInfix l ta qn tb -> TyInfix (f l) ta qn tb + TyKind l t k -> TyKind (f l) t k + +data PAsst l + = ClassA l (QName l) [PType l] + | InfixA l (PType l) (QName l) (PType l) + | IParam l (IPName l) (PType l) + | EqualP l (PType l) (PType l) + deriving (Eq, Show) + +instance Functor PAsst where + fmap f asst = case asst of + ClassA l qn ts -> ClassA (f l) (fmap f qn) (map (fmap f) ts) + InfixA l ta qn tb -> InfixA (f l) (fmap f ta) (fmap f qn) (fmap f tb) + IParam l ipn t -> IParam (f l) (fmap f ipn) (fmap f t) + EqualP l t1 t2 -> EqualP (f l) (fmap f t1) (fmap f t2) + +instance Annotated PAsst where + ann asst = case asst of + ClassA l qn ts -> l + InfixA l ta qn tb -> l + IParam l ipn t -> l + EqualP l t1 t2 -> l + amap f asst = case asst of + ClassA l qn ts -> ClassA (f l) qn ts + InfixA l ta qn tb -> InfixA (f l) ta qn tb + IParam l ipn t -> IParam (f l) ipn t + EqualP l t1 t2 -> EqualP (f l) t1 t2 + + +unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> PType l +unit_tycon l = TyCon l (unit_tycon_name l) +fun_tycon l = TyCon l (fun_tycon_name l) +list_tycon l = TyCon l (list_tycon_name l) +unboxed_singleton_tycon l = TyCon l (unboxed_singleton_tycon_name l) + +tuple_tycon :: l -> Boxed -> Int -> PType l +tuple_tycon l b i = TyCon l (tuple_tycon_name l b i)
+ HSE/ParseUtils.hs view
@@ -0,0 +1,952 @@+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.ParseUtils+-- Copyright : (c) Niklas Broberg 2004-2009,+-- (c) The GHC Team, 1997-2000+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- Utilities for the Haskell-exts parser.+--+-----------------------------------------------------------------------------++module HSE.ParseUtils (+ splitTyConApp -- PType -> P (Name,[Type])+ , checkEnabled -- (Show e, Enabled e) => e -> P ()+ , checkPatternGuards -- [Stmt] -> P ()+ , mkRecConstrOrUpdate -- PExp -> [PFieldUpdate] -> P Exp+ , checkPrec -- Integer -> P Int+ , checkPContext -- PType -> P PContext+ , checkContext -- PContext -> P Context+ , checkAssertion -- PType -> P PAsst+ , checkDataHeader -- PType -> P (Context,Name,[TyVarBind])+ , checkClassHeader -- PType -> P (Context,Name,[TyVarBind])+ , checkInstHeader -- PType -> P (Context,QName,[Type])+ , checkDeriving -- [PType] -> P [Deriving]+ , checkPattern -- PExp -> P Pat+ , checkExpr -- PExp -> P Exp+ , checkType -- PType -> P Type+ , checkValDef -- SrcLoc -> PExp -> Maybe Type -> Rhs -> Binds -> P Decl+ , checkClassBody -- [ClassDecl] -> P [ClassDecl]+ , checkInstBody -- [InstDecl] -> P [InstDecl]+ , checkUnQual -- QName -> P Name+ , checkRevDecls -- [Decl] -> P [Decl]+ , checkRevClsDecls -- [ClassDecl] -> P [ClassDecl]+ , checkRevInstDecls -- [InstDecl] -> P [InstDecl]+ , checkDataOrNew -- DataOrNew -> [QualConDecl] -> P ()+ , checkDataOrNewG -- DataOrNew -> [GadtDecl] -> P ()+ , checkSimpleType -- PType -> P (Name, [TyVarBind])+ , checkSigVar -- PExp -> P Name+ , getGConName -- S.Exp -> P QName+ , mkTyForall -- Maybe [TyVarBind] -> PContext -> PType -> PType+ -- HaRP+ , checkRPattern -- PExp -> P RPat+ -- Hsx+ , checkEqNames -- XName -> XName -> P XName+ , checkPageModule+ , checkHybridModule+ , mkDVar -- [String] -> String+ -- Pragmas+ , checkRuleExpr -- PExp -> P Exp+ , readTool -- Maybe String -> Maybe Tool++ -- Parsed expressions and types+ , PExp(..), PFieldUpdate(..), ParseXAttr(..), PType(..), PContext, PAsst(..)+ , p_unit_con -- PExp+ , p_tuple_con -- Boxed -> Int -> PExp+ , p_unboxed_singleton_con -- PExp+ ) where++import HSE.Annotated.Syntax hiding ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )+import qualified HSE.Annotated.Syntax as S ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )+import HSE.Annotated.Build++import HSE.ParseSyntax+import HSE.ParseMonad+import HSE.Pretty+import HSE.SrcLoc+import HSE.Extension+import HSE.ExtScheme++import Data.List (intersperse)+import Data.Maybe (fromJust)+import Control.Monad (when,liftM)++--- import Debug.Trace (trace)++type L = SrcSpanInfo+type S = SrcSpan++splitTyConApp :: PType L -> P (Name L, [S.Type L])+splitTyConApp t0 = do+ (n, pts) <- split t0 []+ ts <- mapM checkType pts+ return (n,ts)+ where+ split :: PType L -> [PType L] -> P (Name L, [PType L])+ split (TyApp _ t u) ts = split t (u:ts)+ split (TyCon _ (UnQual _ t)) ts = return (t,ts)+ split (TyInfix l a op b) ts = split (TyCon l op) (a:b:ts)+ split _ _ = fail "Illegal data/newtype declaration"++-----------------------------------------------------------------------------+-- Checking for extensions++checkEnabled :: (Show e, Enabled e) => e -> P ()+checkEnabled e = do+ exts <- getExtensions+ if isEnabled e exts+ then return ()+ else fail $ show e ++ " is not enabled"++checkPatternGuards :: [Stmt L] -> P ()+checkPatternGuards [Qualifier _ _] = return ()+checkPatternGuards _ = checkEnabled PatternGuards++-----------------------------------------------------------------------------+-- Checking contexts++-- Check that a context is syntactically correct. Takes care of+-- checking for MPTCs, TypeOperators, TypeFamilies (for eq constraints)+-- and ImplicitParameters, but leaves checking of the class assertion+-- parameters for later.+checkPContext :: PType L -> P (PContext L)+checkPContext (TyTuple l Boxed ts) =+ mapM checkAssertion ts >>= return . CxTuple l+checkPContext (TyCon l (Special _ (UnitCon _))) =+ return $ CxEmpty l+checkPContext (TyParen l t) = do+ c <- checkPContext t+ return $ CxParen l c+checkPContext t = do+ c <- checkAssertion t+ return $ CxSingle (ann c) c++------------------------------------------------------------------------------------------------------------------- WORKING HERE++-- Check a single assertion according to the above, still leaving+-- the class assertion parameters for later.+checkAssertion :: PType L -> P (PAsst L)+-- We cannot even get here unless ImplicitParameters is enabled.+checkAssertion (TyPred _ p@(IParam _ _ _)) = return p+-- We cannot even get here unless TypeFamilies is enabled.+checkAssertion (TyPred _ p@(EqualP _ _ _)) = return p+checkAssertion t = checkAssertion' id [] t+ where -- class assertions must have at least one argument+ checkAssertion' fl ts@(_:xs) (TyCon l c) = do+ when (not $ null xs) $ checkEnabled MultiParamTypeClasses+ when (isSymbol c) $ checkEnabled TypeOperators+ return $ ClassA (fl l) c ts+ checkAssertion' fl ts (TyApp l a t) = do+ -- no check on t at this stage+ checkAssertion' (const (fl l)) (t:ts) a+ checkAssertion' fl ts (TyInfix l a op b) = do+ -- infix operators require TypeOperators+ checkEnabled TypeOperators+ return $ InfixA (fl l) a op b+ checkAssertion' fl ts (TyParen l t) =+ checkAssertion' (const (fl l)) ts t+ checkAssertion' _ _ _ = fail "Illegal class assertion"++isSymbol :: QName L -> Bool+isSymbol (UnQual _ (Symbol _ _)) = True+isSymbol (Qual _ _ (Symbol _ _)) = True+isSymbol _ = False+++-- Checks simple contexts for class and instance+-- headers. If FlexibleContexts is enabled then+-- anything goes, otherwise only tyvars are allowed.+checkSContext :: Maybe (PContext L) -> P (Maybe (S.Context L))+checkSContext (Just ctxt) = case ctxt of+ CxEmpty l -> return $ Just $ S.CxEmpty l+ CxSingle l a -> checkAsst True a >>= return . Just . S.CxSingle l+ CxTuple l as -> mapM (checkAsst True) as >>= return . Just . S.CxTuple l+ CxParen l cx -> checkSContext (Just cx) >>= return . fmap (S.CxParen l)+checkSContext _ = return Nothing++-- Checks ordinary contexts for sigtypes and data type+-- declarations. If FlexibleContexts is enabled then+-- anything goes, otherwise only tyvars OR tyvars+-- applied to types are allowed.+checkContext :: Maybe (PContext L) -> P (Maybe (S.Context L))+checkContext (Just ctxt) = case ctxt of+ CxEmpty l -> return $ Just $ S.CxEmpty l+ CxSingle l a -> checkAsst False a >>= return . Just . S.CxSingle l+ CxTuple l as -> mapM (checkAsst False) as >>= return . Just . S.CxTuple l+ CxParen l cx -> checkSContext (Just cx) >>= return . fmap (S.CxParen l)+checkContext _ = return Nothing++checkAsst :: Bool -> PAsst L -> P (S.Asst L)+checkAsst isSimple asst =+ case asst of+ ClassA l qn pts -> do+ ts <- mapM (checkAsstParam isSimple) pts+ return $ S.ClassA l qn ts+ InfixA l a op b -> do+ [a,b] <- mapM (checkAsstParam isSimple) [a,b]+ return $ S.InfixA l a op b+ IParam l ipn pt -> do+ t <- checkType pt+ return $ S.IParam l ipn t+ EqualP l pa pb -> do+ a <- checkType pa+ b <- checkType pb+ return $ S.EqualP l a b++checkAsstParam :: Bool -> PType L -> P (S.Type L)+checkAsstParam isSimple t = do+ exts <- getExtensions+ if FlexibleContexts `elem` exts+ then checkType t+ else case t of+ TyVar l n -> return $ S.TyVar l n+ TyApp l pf pt | not isSimple -> do+ f <- checkAsstParam isSimple pf+ t <- checkType pt+ return $ S.TyApp l f t+ _ -> fail "Malformed context: FlexibleContexts not enabled"++-----------------------------------------------------------------------------+-- Checking Headers+++checkDataHeader :: PType L -> P (Maybe (S.Context L), DeclHead L)+checkDataHeader (TyForall _ Nothing cs t) = do+ dh <- checkSimple "data/newtype" t []+ cs <- checkContext cs+ return (cs,dh)+checkDataHeader t = do+ dh <- checkSimple "data/newtype" t []+ return (Nothing,dh)++checkClassHeader :: PType L -> P (Maybe (S.Context L), DeclHead L)+checkClassHeader (TyForall _ Nothing cs t) = do+ dh <- checkSimple "class" t []+ cs <- checkSContext cs+ return (cs,dh)+checkClassHeader t = do+ dh <- checkSimple "class" t []+ return (Nothing,dh)++checkSimple :: String -> PType L -> [TyVarBind L] -> P (DeclHead L)+checkSimple kw (TyApp _ l t) xs | isTyVarBind t = checkSimple kw l (toTyVarBind t : xs)+checkSimple _ (TyInfix l t1 (UnQual _ t) t2) []+ | isTyVarBind t1 && isTyVarBind t2 =+ checkEnabled TypeOperators >> return (DHInfix l (toTyVarBind t1) t (toTyVarBind t2))+checkSimple _kw (TyCon l (UnQual _ t)) xs = do+ case t of+ Symbol _ _ -> checkEnabled TypeOperators+ _ -> return ()+ return (DHead l t xs)+checkSimple kw (TyParen l t) xs = do+ dh <- checkSimple kw t xs+ return (DHParen l dh)+checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration")++isTyVarBind :: PType L -> Bool+isTyVarBind (TyVar _ _) = True+isTyVarBind (TyKind _ (TyVar _ _) _) = True+isTyVarBind _ = False++toTyVarBind :: PType L -> TyVarBind L+toTyVarBind (TyVar l n) = UnkindedVar l n+toTyVarBind (TyKind l (TyVar _ n) k) = KindedVar l n k++checkInstHeader :: PType L -> P (Maybe (S.Context L), InstHead L)+checkInstHeader (TyForall _ Nothing cs t) = do+ ih <- checkInsts t []+ cs <- checkSContext cs+ return (cs, ih)+checkInstHeader t = do+ ih <- checkInsts t []+ return (Nothing, ih)+++checkInsts :: PType L -> [PType L] -> P (InstHead L)+checkInsts (TyApp _ l t) ts = checkInsts l (t:ts)+checkInsts (TyCon l c) ts = do+ when (isSymbol c) $ checkEnabled TypeOperators+ ts <- checkTypes ts+ return $ IHead l c ts+checkInsts (TyInfix l a op b) [] = do+ checkEnabled TypeOperators+ [ta,tb] <- checkTypes [a,b]+ return $ IHInfix l ta op tb+checkInsts (TyParen l t) [] = checkInsts t [] >>= return . IHParen l+checkInsts _ _ = fail "Illegal instance declaration"++checkDeriving :: [PType L] -> P [InstHead L]+checkDeriving = mapM (flip checkInsts [])++-----------------------------------------------------------------------------+-- Checking Patterns.++-- We parse patterns as expressions and check for valid patterns below,+-- converting the expression into a pattern at the same time.++checkPattern :: PExp L -> P (Pat L)+checkPattern e = checkPat e []++checkPat :: PExp L -> [Pat L] -> P (Pat L)+checkPat (Con l c) args = return (PApp l c args)+checkPat (App l f x) args = do+ x <- checkPat x []+ checkPat f (x:args)+checkPat (InfixApp _ l op r) args+ | op =~= (QVarOp () (UnQual () (Symbol () "!"))) = do+ -- We must have BangPatterns on+ checkEnabled BangPatterns+ let (e,es) = splitBang r []+ ps <- mapM checkPattern (BangPat (ann op) e:es)+ checkPat l (ps++args)+checkPat e [] = case e of+ Var l (UnQual _ x) -> return (PVar l x)+ Lit l lit -> return (PLit l lit)+ InfixApp loc l op r ->+ case op of+ QConOp _ c -> do+ l <- checkPat l []+ r <- checkPat r []+ return (PInfixApp loc l c r)+ QVarOp ppos (UnQual _ (Symbol _ "+")) -> do+ case (l,r) of+ (Var _ (UnQual _ n@(Ident _ _)), Lit _ (Int kpos k _)) -> do+ let pp = srcInfoSpan ppos+ kp = srcInfoSpan kpos+ return (PNPlusK (loc <** [pp,kp]) n k)+ _ -> patFail ""+ _ -> patFail ""+ TupleSection l mes ->+ if not (any ((==) Nothing) mes)+ then do ps <- mapM (\e -> checkPat e []) (map fromJust mes)+ return (PTuple l ps)+ else fail "Illegal tuple section in pattern"++ List l es -> do+ ps <- mapM checkRPattern es+ if all isStdPat ps+ then return . PList l $ map stripRP ps+ -- we don't allow truly regular patterns unless the extension is enabled+ else checkEnabled RegularPatterns >> return (PRPat l $ map fixRPOpPrec ps)+ where isStdPat :: RPat L -> Bool+ isStdPat (RPPat _ _) = True+ isStdPat (RPAs _ _ p) = isStdPat p+ isStdPat (RPParen _ p) = isStdPat p+ isStdPat _ = False+ stripRP :: RPat L -> Pat L+ stripRP (RPPat _ p) = p+ stripRP (RPAs l n p) = PAsPat l n (stripRP p)+ stripRP (RPParen l p) = PParen l (stripRP p)+ stripRP _ = error "cannot strip RP wrapper if not all patterns are base"++ -- no analogue for FreeSect as they don't (yet?) occur in patterns.+ Paren l e -> do+ p <- checkPat e []+ return (PParen l p)+ AsPat l n e -> do+ p <- checkPat e []+ return (PAsPat l n p)+ WildCard l -> return (PWildCard l)+ IrrPat l e -> do+ p <- checkPat e []+ return (PIrrPat l p)+ ViewPat l e p -> do+ e <- checkExpr e+ p <- checkPat p []+ return (PViewPat l e p)+ RecConstr l c fs -> do+ fs <- mapM checkPatField fs+ return (PRec l c fs)+ NegApp l1 (Lit l2 lit) -> return (PNeg l1 (PLit l2 lit))+ ExpTypeSig l e t -> do+ -- patterns cannot have signatures unless ScopedTypeVariables is enabled.+ checkEnabled ScopedTypeVariables+ p <- checkPat e []+ return (PatTypeSig l p t)++ -- Hsx+ XTag l n attrs mattr cs -> do+ pattrs <- mapM checkPAttr attrs+ pcs <- mapM (\c -> checkPat c []) cs+ mpattr <- maybe (return Nothing)+ (\e -> do p <- checkPat e []+ return $ Just p)+ mattr+ let cps = mkChildrenPat pcs+ return $ PXTag l n pattrs mpattr cps+ XETag l n attrs mattr -> do+ pattrs <- mapM checkPAttr attrs+ mpattr <- maybe (return Nothing)+ (\e -> do p <- checkPat e []+ return $ Just p)+ mattr+ return $ PXETag l n pattrs mpattr+ XPcdata l pcdata -> return $ PXPcdata l pcdata+ XExpTag l e -> do+ p <- checkPat e []+ return $ PXPatTag l p+ XRPats l es -> do+ rps <- mapM checkRPattern es+ return (PXRPats l $ map fixRPOpPrec rps)++ -- Generics+ ExplTypeArg l qn t -> return $ PExplTypeArg l qn t++ -- QuasiQuotation+ QuasiQuote l n q -> return $ PQuasiQuote l n q++ -- BangPatterns+ BangPat l e -> do+ p <- checkPat e []+ return $ PBangPat l p++ PreOp l (QVarOp _ (UnQual _ (Symbol _ "!"))) e -> do+ checkEnabled BangPatterns+ p <- checkPat e []+ return $ PBangPat l p++ e -> patFail $ prettyPrint e++checkPat e _ = patFail $ prettyPrint e++splitBang :: PExp L -> [PExp L] -> (PExp L, [PExp L])+splitBang (App _ f x) es = splitBang f (x:es)+splitBang e es = (e, es)++checkPatField :: PFieldUpdate L -> P (PatField L)+checkPatField (FieldUpdate l n e) = do+ p <- checkPat e []+ return (PFieldPat l n p)+checkPatField (FieldPun l n) = return (PFieldPun l n)+checkPatField (FieldWildcard l) = return (PFieldWildcard l)++checkPAttr :: ParseXAttr L -> P (PXAttr L)+checkPAttr (XAttr l n v) = do p <- checkPat v []+ return $ PXAttr l n p++patFail :: String -> P a+patFail s = fail $ "Parse error in pattern: " ++ s++checkRPattern :: PExp L -> P (RPat L)+checkRPattern e = case e of+ SeqRP l es -> do+ rps <- mapM checkRPattern es+ return $ RPSeq l rps+ PostOp l e op -> do+ rpop <- checkRPatOp op+ rp <- checkRPattern e+ return $ RPOp l rp rpop+ GuardRP l e gs -> do+ rp <- checkPattern e+ return $ RPGuard l rp gs+ EitherRP l e1 e2 -> do+ rp1 <- checkRPattern e1+ rp2 <- checkRPattern e2+ return $ RPEither l rp1 rp2+ CAsRP l n e -> do+ rp <- checkRPattern e+ return $ RPCAs l n rp+ AsPat l n e -> do+ rp <- checkRPattern e+ return $ RPAs l n rp+ Paren l e -> do+ rp <- checkRPattern e+ return $ RPParen l rp+ _ -> do+ p <- checkPattern e+ return $ RPPat (ann p) p++checkRPatOp :: QOp L -> P (RPatOp L)+checkRPatOp o@(QVarOp l (UnQual _ (Symbol _ sym))) =+ case sym of+ "*" -> return $ RPStar l+ "*!" -> return $ RPStarG l+ "+" -> return $ RPPlus l+ "+!" -> return $ RPPlusG l+ "?" -> return $ RPOpt l+ "?!" -> return $ RPOptG l+ _ -> rpOpFail o+checkRPatOp o = rpOpFail o++rpOpFail sym = fail $ "Unrecognized regular pattern operator: " ++ prettyPrint sym++fixRPOpPrec :: RPat L -> RPat L+fixRPOpPrec rp = case rp of+ RPOp l rp rpop -> fPrecOp rp (flip (RPOp l) rpop)+ RPEither l rp1 rp2 -> RPEither l (fixRPOpPrec rp1) (fixRPOpPrec rp2)+ RPSeq l rps -> RPSeq l $ map fixRPOpPrec rps+ RPCAs l n rp -> RPCAs l n $ fixRPOpPrec rp+ RPAs l n rp -> RPAs l n $ fixRPOpPrec rp+ RPParen l rp -> RPParen l $ fixRPOpPrec rp+ _ -> rp++ where fPrecOp :: RPat L -> (RPat L -> RPat L) -> RPat L+ fPrecOp (RPOp l rp rpop) f = fPrecOp rp (f . flip (RPOp l) rpop)+ fPrecOp (RPCAs l n rp) f = fPrecAs rp f (RPCAs l n)+ fPrecOp (RPAs l n rp) f = fPrecAs rp f (RPAs l n)+ fPrecOp rp f = f $ fixRPOpPrec rp+ fPrecAs :: RPat L -> (RPat L -> RPat L) -> (RPat L -> RPat L) -> RPat L+ fPrecAs (RPCAs l n rp) f g = fPrecAs rp f (g . RPCAs l n)+ fPrecAs (RPAs l n rp) f g = fPrecAs rp f (g . RPAs l n)+ fPrecAs rp f g = g . f $ fixRPOpPrec rp+++mkChildrenPat :: [Pat L] -> [Pat L]+mkChildrenPat ps = mkCPAux ps []+ where mkCPAux :: [Pat L] -> [Pat L] -> [Pat L]+ mkCPAux [] qs = reverse qs+ mkCPAux (p:ps) qs = case p of+ (PRPat l rps) -> [mkCRP l ps (reverse rps ++ map (\q -> RPPat (ann q) q) qs)]+ _ -> mkCPAux ps (p:qs)++ mkCRP :: L -> [Pat L] -> [RPat L] -> Pat L+ mkCRP l [] rps = PXRPats l $ reverse rps+ mkCRP _ (p:ps) rps = case p of+ (PXRPats l rqs) -> mkCRP l ps (reverse rqs ++ rps)+ _ -> mkCRP (ann p) ps (RPPat (ann p) p : rps)++-----------------------------------------------------------------------------+-- Check Expression Syntax++checkExpr :: PExp L -> P (S.Exp L)+checkExpr e = case e of+ Var l v -> return $ S.Var l v+ FreeSectSlot l -> return (S.FreeSectSlot l)+ IPVar l v -> return $ S.IPVar l v+ Con l c -> return $ S.Con l c+ Lit l lit -> return $ S.Lit l lit+ InfixApp l e1 op e2 -> check2Exprs e1 e2 (flip (S.InfixApp l) op)+ App l e1 e2 -> check2Exprs e1 e2 (S.App l)+ NegApp l e -> check1Expr e (S.NegApp l)+ Lambda loc ps e -> check1Expr e (S.Lambda loc ps)+ Let l bs e -> check1Expr e (S.Let l bs)+ If l e1 e2 e3 -> check3Exprs e1 e2 e3 (S.If l)+ Case l e alts -> do+ e <- checkExpr e+ return (S.Case l e alts)+ Do l stmts -> checkDo stmts >> return (S.Do l stmts)+ MDo l stmts -> checkDo stmts >> return (S.MDo l stmts)+ TupleSection l mes -> if not (any ((==) Nothing) mes)+ then checkManyExprs (map fromJust mes) (S.Tuple l)+ else do checkEnabled TupleSections+ mes' <- mapM mCheckExpr mes+ return $ S.TupleSection l mes'+++ List l es -> checkManyExprs es (S.List l)+ -- XXX DUBIOUS imitation of P aren case!!....+ FSContext l e -> case e of+ PostOp _ e1 op -> check1Expr e1 (flip (S.LeftSection l) op)+ PreOp _ op e2 -> check1Expr e2 (S.RightSection l op)+ _ -> check1Expr e (S.FSContext l)+ -- Since we don't parse things as left or right sections, we need to mangle them into that.+ Paren l e -> case e of+ PostOp _ e1 op -> check1Expr e1 (flip (S.LeftSection l) op)+ PreOp _ op e2 -> check1Expr e2 (S.RightSection l op)+ _ -> check1Expr e (S.Paren l)+ RecConstr l c fields -> do+ fields <- mapM checkField fields+ return (S.RecConstr l c fields)+ RecUpdate l e fields -> do+ fields <- mapM checkField fields+ e <- checkExpr e+ return (S.RecUpdate l e fields)+ EnumFrom l e -> check1Expr e (S.EnumFrom l)+ EnumFromTo l e1 e2 -> check2Exprs e1 e2 (S.EnumFromTo l)+ EnumFromThen l e1 e2 -> check2Exprs e1 e2 (S.EnumFromThen l)+ EnumFromThenTo l e1 e2 e3 -> check3Exprs e1 e2 e3 (S.EnumFromThenTo l)+ -- a parallel list comprehension, which could be just a simple one+ ParComp l e qualss -> do+ e <- checkExpr e+ case qualss of+ [quals] -> return (S.ListComp l e quals)+ _ -> return (S.ParComp l e qualss)+ ExpTypeSig loc e ty -> do+ e <- checkExpr e+ return (S.ExpTypeSig loc e ty)++ --Template Haskell+ BracketExp l e -> return $ S.BracketExp l e+ SpliceExp l e -> return $ S.SpliceExp l e+ TypQuote l q -> return $ S.TypQuote l q+ VarQuote l q -> return $ S.VarQuote l q+ QuasiQuote l n q -> return $ S.QuasiQuote l n q++ -- Hsx+ XTag l n attrs mattr cs -> do attrs <- mapM checkAttr attrs+ cs <- mapM checkExpr cs+ mattr <- maybe (return Nothing)+ (\e -> checkExpr e >>= return . Just)+ mattr+ return $ S.XTag l n attrs mattr cs+ XETag l n attrs mattr -> do attrs <- mapM checkAttr attrs+ mattr <- maybe (return Nothing)+ (\e -> checkExpr e >>= return . Just)+ mattr+ return $ S.XETag l n attrs mattr+ XPcdata l p -> return $ S.XPcdata l p+ XExpTag l e -> do e <- checkExpr e+ return $ S.XExpTag l e+ XChildTag l es -> do es <- mapM checkExpr es+ return $ S.XChildTag l es+ -- Pragmas+ CorePragma l s e -> check1Expr e (S.CorePragma l s)+ SCCPragma l s e -> check1Expr e (S.SCCPragma l s)+ GenPragma l s xx yy e -> check1Expr e (S.GenPragma l s xx yy)+-- UnknownExpPragma n s -> return $ S.UnknownExpPragma n s++ -- Arrows+ Proc l p e -> do e <- checkExpr e+ return $ S.Proc l p e+ LeftArrApp l e1 e2 -> check2Exprs e1 e2 (S.LeftArrApp l)+ RightArrApp l e1 e2 -> check2Exprs e1 e2 (S.RightArrApp l)+ LeftArrHighApp l e1 e2 -> check2Exprs e1 e2 (S.LeftArrHighApp l)+ RightArrHighApp l e1 e2 -> check2Exprs e1 e2 (S.RightArrHighApp l)++ _ -> fail $ "Parse error in expression: " ++ prettyPrint e++checkAttr :: ParseXAttr L -> P (S.XAttr L)+checkAttr (XAttr l n v) = do v <- checkExpr v+ return $ S.XAttr l n v++checkDo [] = fail "Parse error: Last statement in a do-block must be an expression"+checkDo [Qualifier _ _] = return ()+checkDo (_:xs) = checkDo xs++-- type signature for polymorphic recursion!!+check1Expr :: PExp L -> (S.Exp L -> a) -> P a+check1Expr e1 f = do+ e1 <- checkExpr e1+ return (f e1)++check2Exprs :: PExp L -> PExp L -> (S.Exp L -> S.Exp L -> a) -> P a+check2Exprs e1 e2 f = do+ e1 <- checkExpr e1+ e2 <- checkExpr e2+ return (f e1 e2)++check3Exprs :: PExp L -> PExp L -> PExp L -> (S.Exp L -> S.Exp L -> S.Exp L -> a) -> P a+check3Exprs e1 e2 e3 f = do+ e1 <- checkExpr e1+ e2 <- checkExpr e2+ e3 <- checkExpr e3+ return (f e1 e2 e3)++checkManyExprs :: [PExp L] -> ([S.Exp L] -> a) -> P a+checkManyExprs es f = do+ es <- mapM checkExpr es+ return (f es)++mCheckExpr :: Maybe (PExp L) -> P (Maybe (S.Exp L))+mCheckExpr Nothing = return Nothing+mCheckExpr (Just e) = checkExpr e >>= return . Just++checkRuleExpr :: PExp L -> P (S.Exp L)+checkRuleExpr = checkExpr++readTool :: Maybe String -> Maybe Tool+readTool = fmap readC+ where readC str = case str of+ "GHC" -> GHC+ "HUGS" -> HUGS+ "NHC98" -> NHC98+ "YHC" -> YHC+ "HADDOCK" -> HADDOCK+ _ -> UnknownTool str++checkField :: PFieldUpdate L -> P (S.FieldUpdate L)+checkField (FieldUpdate l n e) = check1Expr e (S.FieldUpdate l n)+checkField (FieldPun l n) = return $ S.FieldPun l n+checkField (FieldWildcard l) = return $ S.FieldWildcard l++getGConName :: S.Exp L -> P (QName L)+getGConName (S.Con _ n) = return n+getGConName (S.List l []) = return (list_cons_name l)+getGConName _ = fail "Expression in reification is not a name"++-----------------------------------------------------------------------------+-- Check Equation Syntax++checkValDef :: L -> PExp L -> Maybe (S.Type L) -> Rhs L -> Maybe (Binds L) -> P (Decl L)+checkValDef l lhs optsig rhs whereBinds = do+ mlhs <- isFunLhs lhs []+ let whpt = srcInfoPoints l+ case mlhs of+ Just (f,es,b,pts) -> do+ ps <- mapM checkPattern es+ let l' = l { srcInfoPoints = pts ++ whpt }+ case optsig of -- only pattern bindings can have signatures+ Nothing -> return (FunBind l $+ if b then [Match l' f ps rhs whereBinds]+ else let (a:bs) = ps + in [InfixMatch l' a f bs rhs whereBinds])+ Just _ -> fail "Cannot give an explicit type signature to a function binding"+ Nothing -> do+ lhs <- checkPattern lhs+ return (PatBind l lhs optsig rhs whereBinds)++-- A variable binding is parsed as a PatBind.++isFunLhs :: PExp L -> [PExp L] -> P (Maybe (Name L, [PExp L], Bool, [S]))+isFunLhs (InfixApp ll l (QVarOp loc (UnQual _ op)) r) es+ | op =~= (Symbol () "!") = do+ exts <- getExtensions+ if BangPatterns `elem` exts+ then let (b,bs) = splitBang r []+ in isFunLhs l (BangPat loc b : bs ++ es)+ else return $ Just (op, l:r:es, False, []) -- It's actually a definition of the operator !+ | otherwise = return $ Just (op, l:r:es, False, [])+isFunLhs (App _ (Var _ (UnQual _ f)) e) es = return $ Just (f, e:es, True, [])+isFunLhs (App _ f e) es = isFunLhs f (e:es)+isFunLhs (Var _ (UnQual _ f)) es@(_:_) = return $ Just (f, es, True, [])+-- FreeSect: We don't need (yet?) to worry about being in a FunLhs!+isFunLhs (Paren l f) es@(_:_) = do mlhs <- isFunLhs f es + case mlhs of+ Just (f,es,b,pts) -> + let [x,y] = srcInfoPoints l+ in return $ Just (f,es,b,x:pts++[y])+ _ -> return Nothing+isFunLhs _ _ = return Nothing++-- Separating between signature declarations and value definitions in+-- a post-processing step++checkSigVar :: PExp L -> P (Name L)+checkSigVar (Var _ (UnQual _ n)) = return n+checkSigVar e = fail $ "Left-hand side of type signature is not a variable: " ++ prettyPrint e++-----------------------------------------------------------------------------+-- In a class or instance body, a pattern binding must be of a variable.++checkClassBody :: [ClassDecl L] -> P [ClassDecl L]+checkClassBody decls = do+ mapM_ checkClassMethodDef decls+ return decls+ where checkClassMethodDef (ClsDecl _ decl) = checkMethodDef decl+ checkClassMethodDef _ = return ()++checkInstBody :: [InstDecl L] -> P [InstDecl L]+checkInstBody decls = do+ mapM_ checkInstMethodDef decls+ return decls+ where checkInstMethodDef (InsDecl _ decl) = checkMethodDef decl+ checkInstMethodDef _ = return ()++checkMethodDef :: Decl L -> P ()+checkMethodDef (PatBind _ (PVar _ _) _ _ _) = return ()+checkMethodDef (PatBind loc _ _ _ _) =+ fail "illegal method definition" -- `atSrcLoc` loc+checkMethodDef _ = return ()++-----------------------------------------------------------------------------+-- Check that an identifier or symbol is unqualified.+-- For occasions when doing this in the grammar would cause conflicts.++checkUnQual :: QName L -> P (Name L)+checkUnQual (Qual _ _ _) = fail "Illegal qualified name"+checkUnQual (UnQual _ n) = return n+checkUnQual (Special _ _) = fail "Illegal special name"++-----------------------------------------------------------------------------+-- Check that two xml tag names are equal+checkEqNames :: XName L -> XName L -> P (XName L)+checkEqNames n@(XName _ n1) (XName _ n2)+ | n1 == n2 = return n+checkEqNames n@(XDomName _ d1 n1) (XDomName _ d2 n2)+ | n1 == n2 && d1 == d2 = return n+checkEqNames n m = fail $ "opening tag '" ++ showTag n +++ "' does not match closing tag '" ++ showTag m ++ "'"+ where+ showTag (XName _ n) = n+ showTag (XDomName _ d n) = d ++ ":" ++ n+++-----------------------------------------------------------------------------+-- Miscellaneous utilities++checkPrec :: Integer -> P Int+checkPrec i | 0 <= i && i <= 9 = return (fromInteger i)+checkPrec i | otherwise = fail ("Illegal precedence " ++ show i)++mkRecConstrOrUpdate :: PExp L -> [PFieldUpdate L] -> P (PExp L)+mkRecConstrOrUpdate (Con l c) fs = return (RecConstr l c fs)+mkRecConstrOrUpdate e fs@(_:_) = return (RecUpdate (ann e) e fs)+mkRecConstrOrUpdate _ _ = fail "Empty record update"++-----------------------------------------------------------------------------+-- Reverse a list of declarations, merging adjacent FunBinds of the+-- same name and checking that their arities match.++checkRevDecls :: [Decl L] -> P [Decl L]+checkRevDecls = mergeFunBinds []+ where+ mergeFunBinds revDs [] = return revDs+ mergeFunBinds revDs (FunBind l ms1@(Match _ name ps _ _:_):ds1) =+ mergeMatches ms1 ds1 l+ where+ arity = length ps+ mergeMatches ms' (FunBind _ ms@(Match loc name' ps' _ _:_):ds) l+ | name' =~= name =+ if length ps' /= arity+ then fail ("arity mismatch for '" ++ prettyPrint name ++ "'")+ -- `atSrcLoc` loc+ else mergeMatches (ms++ms') ds (loc <++> l)+ mergeMatches ms' ds l = mergeFunBinds (FunBind l ms':revDs) ds+ mergeFunBinds revDs (FunBind l ims1@(InfixMatch _ _ name _ _ _:_):ds1) =+ mergeInfix ims1 ds1 l+ where+ mergeInfix ims' (FunBind _ ims@(InfixMatch loc _ name' _ _ _:_):ds) l+ | name' =~= name =+ mergeInfix (ims++ims') ds (loc <++> l)+ mergeInfix ms' ds l = mergeFunBinds (FunBind l ms':revDs) ds+ mergeFunBinds revDs (d:ds) = mergeFunBinds (d:revDs) ds++checkRevClsDecls :: [ClassDecl L] -> P [ClassDecl L]+checkRevClsDecls = mergeClsFunBinds []+ where+ mergeClsFunBinds revDs [] = return revDs+ mergeClsFunBinds revDs (ClsDecl l (FunBind _ ms1@(Match _ name ps _ _:_)):ds1) =+ mergeMatches ms1 ds1 l+ where+ arity = length ps+ mergeMatches ms' (ClsDecl _ (FunBind _ ms@(Match loc name' ps' _ _:_)):ds) l+ | name' =~= name =+ if length ps' /= arity+ then fail ("arity mismatch for '" ++ prettyPrint name ++ "'")+ -- `atSrcLoc` loc+ else mergeMatches (ms++ms') ds (loc <++> l)+ mergeMatches ms' ds l = mergeClsFunBinds (ClsDecl l (FunBind l ms'):revDs) ds+ mergeClsFunBinds revDs (ClsDecl l (FunBind _ ims1@(InfixMatch _ _ name _ _ _:_)):ds1) =+ mergeInfix ims1 ds1 l+ where+ mergeInfix ims' (ClsDecl _ (FunBind _ ims@(InfixMatch loc _ name' _ _ _:_)):ds) l+ | name' =~= name =+ mergeInfix (ims++ims') ds (loc <++> l)+ mergeInfix ms' ds l = mergeClsFunBinds (ClsDecl l (FunBind l ms'):revDs) ds+ mergeClsFunBinds revDs (d:ds) = mergeClsFunBinds (d:revDs) ds++checkRevInstDecls :: [InstDecl L] -> P [InstDecl L]+checkRevInstDecls = mergeInstFunBinds []+ where+ mergeInstFunBinds :: [InstDecl L] -> [InstDecl L] -> P [InstDecl L]+ mergeInstFunBinds revDs [] = return revDs+ mergeInstFunBinds revDs (InsDecl l (FunBind _ ms1@(Match _ name ps _ _:_)):ds1) =+ mergeMatches ms1 ds1 l+ where+ arity = length ps+ mergeMatches ms' (InsDecl _ (FunBind _ ms@(Match loc name' ps' _ _:_)):ds) l+ | name' =~= name =+ if length ps' /= arity+ then fail ("arity mismatch for '" ++ prettyPrint name ++ "'")+ -- `atSrcLoc` loc+ else mergeMatches (ms++ms') ds (loc <++> l)+ mergeMatches ms' ds l = mergeInstFunBinds (InsDecl l (FunBind l ms'):revDs) ds+ mergeInstFunBinds revDs (InsDecl l (FunBind _ ims1@(InfixMatch _ _ name _ _ _:_)):ds1) =+ mergeInfix ims1 ds1 l+ where+ mergeInfix ims' (InsDecl _ (FunBind _ ims@(InfixMatch loc _ name' _ _ _:_)):ds) l+ | name' =~= name =+ mergeInfix (ims++ims') ds (loc <++> l)+ mergeInfix ms' ds l = mergeInstFunBinds (InsDecl l (FunBind l ms'):revDs) ds+ mergeInstFunBinds revDs (d:ds) = mergeInstFunBinds (d:revDs) ds++----------------------------------------------------------------+-- Check that newtype declarations have+-- the right number (1) of constructors++checkDataOrNew :: DataOrNew L -> [QualConDecl L] -> P ()+checkDataOrNew (DataType _) _ = return ()+checkDataOrNew (NewType _) [QualConDecl _ _ _ x] = cX x >> return ()+ where cX (ConDecl _ _ [_]) = return ()+ cX (RecDecl _ _ [_]) = return ()+ cX _ = fail "newtype declaration constructor must have exactly one parameter."+checkDataOrNew _ _ = fail "newtype declaration must have exactly one constructor."++checkDataOrNewG :: DataOrNew L -> [GadtDecl L] -> P ()+checkDataOrNewG (DataType _) _ = return ()+checkDataOrNewG (NewType _) [x] = return ()+checkDataOrNewG _ _ = fail "newtype declaration must have exactly one constructor."++checkSimpleType :: PType L -> P (DeclHead L)+checkSimpleType t = checkSimple "test" t []++---------------------------------------+-- Check actual types++checkType :: PType L -> P (S.Type L)+checkType t = checkT t False++checkT :: PType L -> Bool -> P (S.Type L)+checkT t simple = case t of+ TyForall l tvs@Nothing cs pt -> do+ when (simple) $ checkEnabled ExplicitForall+ ctxt <- checkContext cs+ check1Type pt (S.TyForall l Nothing ctxt)+ TyForall l tvs cs pt -> do+ checkEnabled ExplicitForall+ ctxt <- checkContext cs+ check1Type pt (S.TyForall l tvs ctxt)+ TyFun l at rt -> check2Types at rt (S.TyFun l)+ TyTuple l b pts -> checkTypes pts >>= return . S.TyTuple l b+ TyList l pt -> check1Type pt (S.TyList l)+ TyApp l ft at -> check2Types ft at (S.TyApp l)+ TyVar l n -> return $ S.TyVar l n+ TyCon l n -> do+ when (isSymbol n) $ checkEnabled TypeOperators+ return $ S.TyCon l n+ TyParen l pt -> check1Type pt (S.TyParen l)+ -- Here we know that t will be used as an actual type (and not a data constructor)+ -- so we can check that TypeOperators are enabled.+ TyInfix l at op bt -> checkEnabled TypeOperators >> check2Types at bt (flip (S.TyInfix l) op)+ TyKind l pt k -> check1Type pt (flip (S.TyKind l) k)++ -- TyPred cannot be a valid type+ _ -> fail $ "Parse error in type: " ++ prettyPrint t++check1Type :: PType L -> (S.Type L -> S.Type L) -> P (S.Type L)+check1Type pt f = checkT pt True >>= return . f++check2Types :: PType L -> PType L -> (S.Type L -> S.Type L -> S.Type L) -> P (S.Type L)+check2Types at bt f = checkT at True >>= \a -> checkT bt True >>= \b -> return (f a b)++checkTypes :: [PType L] -> P [S.Type L]+checkTypes = mapM (flip checkT True)++---------------------------------------+-- Converting a complete page++checkPageModule :: PExp L -> ([ModulePragma L],[S],L) -> P (Module L)+checkPageModule xml (os,ss,inf) = do+ mod <- getModuleName+ xml <- checkExpr xml+ case xml of+ S.XTag l xn ats mattr cs -> return $ XmlPage (inf<++>l<**(srcInfoPoints l ++ ss)) (ModuleName l mod) os xn ats mattr cs+ S.XETag l xn ats mattr -> return $ XmlPage (inf<++>l<**(srcInfoPoints l ++ ss)) (ModuleName l mod) os xn ats mattr []++checkHybridModule :: PExp L -> Module L -> S -> S -> P (Module L)+checkHybridModule xml (Module inf mh os is ds) s1 s2 = do+ xml <- checkExpr xml+ case xml of+ S.XTag l xn ats mattr cs -> return $ XmlHybrid (inf<++>l<**(s1 : srcInfoPoints inf ++ s2 : srcInfoPoints l))+ mh os is ds xn ats mattr cs+ S.XETag l xn ats mattr -> return $ XmlHybrid (inf<++>l<**(s1 : srcInfoPoints inf ++ s2 : srcInfoPoints l))+ mh os is ds xn ats mattr []++---------------------------------------+-- Handle dash-identifiers++mkDVar :: [String] -> String+mkDVar = concat . intersperse "-"++---------------------------------------+-- Combine adjacent for-alls. NO!+--+-- A valid type must have one for-all at the top of the type, or of the fn arg types++mkTyForall :: L -> Maybe [TyVarBind L] -> Maybe (PContext L) -> PType L -> PType L+mkTyForall l mtvs ctxt ty = TyForall l mtvs ctxt ty
+ HSE/Parser.hs view
@@ -0,0 +1,174 @@+module HSE.Parser + ( + -- * General parsing + Parseable(..), + ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult, + -- * Parsing of specific AST elements + -- ** Modules + parseModule, parseModuleWithMode, parseModuleWithComments, + -- ** Expressions + parseExp, parseExpWithMode, parseExpWithComments, + -- ** Statements + parseStmt, parseStmtWithMode, parseStmtWithComments, + -- ** Patterns + parsePat, parsePatWithMode, parsePatWithComments, + -- ** Declarations + parseDecl, parseDeclWithMode, parseDeclWithComments, + -- ** Types + parseType, parseTypeWithMode, parseTypeWithComments, + -- ** Option pragmas + getTopPragmas + ) where + + +import HSE.InternalParser ( ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult ) +import qualified HSE.InternalParser as P + +import HSE.Annotated.Syntax +import qualified HSE.Syntax as S +import HSE.Annotated.Simplify + +import HSE.SrcLoc +import HSE.Comments + +getTopPragmas :: String -> ParseResult [S.ModulePragma] +getTopPragmas = fmap (map sModulePragma) . P.getTopPragmas + +-- | Class to reuse the parse function at many different types. +class Parseable ast where + -- | Parse a string with default mode. + parse :: String -> ParseResult ast + -- | Parse a string with an explicit mode. + parseWithMode :: ParseMode -> String -> ParseResult ast + -- | Parse a string with an explicit mode, returning all comments along the AST + parseWithComments :: ParseMode -> String -> ParseResult (ast, [Comment]) + + +instance SrcInfo loc => Parseable (Module loc) where + parse = fmap (fmap fromSrcInfo) . P.parseModule + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseModuleWithMode + parseWithComments md s = P.parseModuleWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + +instance SrcInfo loc => Parseable (Exp loc) where + parse = fmap (fmap fromSrcInfo) . P.parseExp + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseExpWithMode + parseWithComments md s = P.parseExpWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + +instance SrcInfo loc => Parseable (Pat loc) where + parse = fmap (fmap fromSrcInfo) . P.parsePat + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parsePatWithMode + parseWithComments md s = P.parsePatWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + +instance SrcInfo loc => Parseable (Decl loc) where + parse = fmap (fmap fromSrcInfo) . P.parseDecl + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseDeclWithMode + parseWithComments md s = P.parseDeclWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + +instance SrcInfo loc => Parseable (Type loc) where + parse = fmap (fmap fromSrcInfo) . P.parseType + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseTypeWithMode + parseWithComments md s = P.parseTypeWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + +instance SrcInfo loc => Parseable (Stmt loc) where + parse = fmap (fmap fromSrcInfo) . P.parseStmt + parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseStmtWithMode + parseWithComments md s = P.parseStmtWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs) + + +-- | Parse of a string, which should contain a complete Haskell module. +parseModule :: String -> ParseResult S.Module +parseModule = fmap sModule . P.parseModule + +-- | Parse of a string containing a complete Haskell module, using an explicit mode. +parseModuleWithMode :: ParseMode -> String -> ParseResult S.Module +parseModuleWithMode = (fmap sModule .) . P.parseModuleWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parseModuleWithComments :: ParseMode -> String -> ParseResult (S.Module, [Comment]) +parseModuleWithComments = (fmap (\(mod, cs) -> (sModule mod, cs)) .) . P.parseModuleWithComments + +-- | Parse of a string containing a Haskell expression. +parseExp :: String -> ParseResult S.Exp +parseExp = fmap sExp . P.parseExp + +-- | Parse of a string containing a Haskell expression, using an explicit mode. +parseExpWithMode :: ParseMode -> String -> ParseResult S.Exp +parseExpWithMode = (fmap sExp .) . P.parseExpWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parseExpWithComments :: ParseMode -> String -> ParseResult (S.Exp, [Comment]) +parseExpWithComments = (fmap (\(e, cs) -> (sExp e, cs)) .) . P.parseExpWithComments + +-- | Parse of a string containing a Haskell pattern. +parsePat :: String -> ParseResult S.Pat +parsePat = fmap sPat . P.parsePat + +-- | Parse of a string containing a Haskell pattern, using an explicit mode. +parsePatWithMode :: ParseMode -> String -> ParseResult S.Pat +parsePatWithMode = (fmap sPat .) . P.parsePatWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parsePatWithComments :: ParseMode -> String -> ParseResult (S.Pat, [Comment]) +parsePatWithComments = (fmap (\(p, cs) -> (sPat p, cs)) .) . P.parsePatWithComments + +-- | Parse of a string containing a Haskell top-level declaration. +parseDecl :: String -> ParseResult S.Decl +parseDecl = fmap sDecl . P.parseDecl + +-- | Parse of a string containing a Haskell top-level declaration, using an explicit mode. +parseDeclWithMode :: ParseMode -> String -> ParseResult S.Decl +parseDeclWithMode = (fmap sDecl .) . P.parseDeclWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parseDeclWithComments :: ParseMode -> String -> ParseResult (S.Decl, [Comment]) +parseDeclWithComments = (fmap (\(decl, cs) -> (sDecl decl, cs)) .) . P.parseDeclWithComments + +-- | Parse of a string containing a Haskell type. +parseType :: String -> ParseResult S.Type +parseType = fmap sType . P.parseType + +-- | Parse of a string containing a Haskell type, using an explicit mode. +parseTypeWithMode :: ParseMode -> String -> ParseResult S.Type +parseTypeWithMode = (fmap sType .) . P.parseTypeWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parseTypeWithComments :: ParseMode -> String -> ParseResult (S.Type, [Comment]) +parseTypeWithComments = (fmap (\(t, cs) -> (sType t, cs)) .) . P.parseTypeWithComments + +-- | Parse of a string containing a Haskell type. +parseStmt :: String -> ParseResult S.Stmt +parseStmt = fmap sStmt . P.parseStmt + +-- | Parse of a string containing a Haskell type, using an explicit mode. +parseStmtWithMode :: ParseMode -> String -> ParseResult S.Stmt +parseStmtWithMode = (fmap sStmt .) . P.parseStmtWithMode + +-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments. +parseStmtWithComments :: ParseMode -> String -> ParseResult (S.Stmt, [Comment]) +parseStmtWithComments = (fmap (\(s, cs) -> (sStmt s, cs)) .) . P.parseStmtWithComments + + +instance Parseable S.Module where + parse = parseModule + parseWithMode = parseModuleWithMode + parseWithComments = parseModuleWithComments + +instance Parseable S.Exp where + parse = parseExp + parseWithMode = parseExpWithMode + parseWithComments = parseExpWithComments + +instance Parseable S.Pat where + parse = parsePat + parseWithMode = parsePatWithMode + parseWithComments = parsePatWithComments + +instance Parseable S.Decl where + parse = parseDecl + parseWithMode = parseDeclWithMode + parseWithComments = parseDeclWithComments + +instance Parseable S.Type where + parse = parseType + parseWithMode = parseTypeWithMode + parseWithComments = parseTypeWithComments
+ HSE/Pretty.hs view
@@ -0,0 +1,1661 @@+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Pretty+-- Copyright : (c) Niklas Broberg 2004-2009,+-- (c) The GHC Team, Noel Winstanley 1997-2000+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- Pretty printer for Haskell with extensions.+--+-----------------------------------------------------------------------------++module HSE.Pretty (+ -- * Pretty printing+ Pretty,+ prettyPrintStyleMode, prettyPrintWithMode, prettyPrint,+ -- * Pretty-printing styles (from "Text.PrettyPrint.HughesPJ")+ P.Style(..), P.style, P.Mode(..),+ -- * Haskell formatting modes+ PPHsMode(..), Indent, PPLayout(..), defaultMode) where++import HSE.Syntax+import qualified HSE.Annotated.Syntax as A+import HSE.Annotated.Simplify+import qualified HSE.ParseSyntax as P++import HSE.SrcLoc++import qualified Text.PrettyPrint as P+import Data.List (intersperse)++infixl 5 $$$++-----------------------------------------------------------------------------++-- | Varieties of layout we can use.+data PPLayout = PPOffsideRule -- ^ classical layout+ | PPSemiColon -- ^ classical layout made explicit+ | PPInLine -- ^ inline decls, with newlines between them+ | PPNoLayout -- ^ everything on a single line+ deriving Eq++type Indent = Int++-- | Pretty-printing parameters.+--+-- /Note:/ the 'onsideIndent' must be positive and less than all other indents.+data PPHsMode = PPHsMode {+ -- | indentation of a class or instance+ classIndent :: Indent,+ -- | indentation of a @do@-expression+ doIndent :: Indent,+ -- | indentation of the body of a+ -- @case@ expression+ caseIndent :: Indent,+ -- | indentation of the declarations in a+ -- @let@ expression+ letIndent :: Indent,+ -- | indentation of the declarations in a+ -- @where@ clause+ whereIndent :: Indent,+ -- | indentation added for continuation+ -- lines that would otherwise be offside+ onsideIndent :: Indent,+ -- | blank lines between statements?+ spacing :: Bool,+ -- | Pretty-printing style to use+ layout :: PPLayout,+ -- | add GHC-style @LINE@ pragmas to output?+ linePragmas :: Bool+ }++-- | The default mode: pretty-print using the offside rule and sensible+-- defaults.+defaultMode :: PPHsMode+defaultMode = PPHsMode{+ classIndent = 8,+ doIndent = 3,+ caseIndent = 4,+ letIndent = 4,+ whereIndent = 6,+ onsideIndent = 2,+ spacing = True,+ layout = PPOffsideRule,+ linePragmas = False+ }++-- | Pretty printing monad+newtype DocM s a = DocM (s -> a)++instance Functor (DocM s) where+ fmap f xs = do x <- xs; return (f x)++instance Monad (DocM s) where+ (>>=) = thenDocM+ (>>) = then_DocM+ return = retDocM++{-# INLINE thenDocM #-}+{-# INLINE then_DocM #-}+{-# INLINE retDocM #-}+{-# INLINE unDocM #-}+{-# INLINE getPPEnv #-}++thenDocM :: DocM s a -> (a -> DocM s b) -> DocM s b+thenDocM m k = DocM $ (\s -> case unDocM m $ s of a -> unDocM (k a) $ s)++then_DocM :: DocM s a -> DocM s b -> DocM s b+then_DocM m k = DocM $ (\s -> case unDocM m $ s of _ -> unDocM k $ s)++retDocM :: a -> DocM s a+retDocM a = DocM (\_s -> a)++unDocM :: DocM s a -> (s -> a)+unDocM (DocM f) = f++-- all this extra stuff, just for this one function.+getPPEnv :: DocM s s+getPPEnv = DocM id++-- So that pp code still looks the same+-- this means we lose some generality though++-- | The document type produced by these pretty printers uses a 'PPHsMode'+-- environment.+type Doc = DocM PPHsMode P.Doc++-- | Things that can be pretty-printed, including all the syntactic objects+-- in "HSE.Syntax" and "HSE.Annotated.Syntax".+class Pretty a where+ -- | Pretty-print something in isolation.+ pretty :: a -> Doc+ -- | Pretty-print something in a precedence context.+ prettyPrec :: Int -> a -> Doc+ pretty = prettyPrec 0+ prettyPrec _ = pretty++-- The pretty printing combinators++empty :: Doc+empty = return P.empty++nest :: Int -> Doc -> Doc+nest i m = m >>= return . P.nest i+++-- Literals++text, ptext :: String -> Doc+text = return . P.text+ptext = return . P.text++char :: Char -> Doc+char = return . P.char++int :: Int -> Doc+int = return . P.int++integer :: Integer -> Doc+integer = return . P.integer++float :: Float -> Doc+float = return . P.float++double :: Double -> Doc+double = return . P.double++rational :: Rational -> Doc+rational = return . P.rational++-- Simple Combining Forms++--fscontexts :: Doc -> Doc+--fscontexts d = d >>= return . P.fscontexts+parens, brackets, braces,quotes,doubleQuotes :: Doc -> Doc+parens d = d >>= return . P.parens+brackets d = d >>= return . P.brackets+braces d = d >>= return . P.braces+quotes d = d >>= return . P.quotes+doubleQuotes d = d >>= return . P.doubleQuotes++--fscontextsIf :: Bool -> Doc -> Doc+--fscontextsIf True = fscontexts+--fscontextsIf False = id++parensIf :: Bool -> Doc -> Doc+parensIf True = parens+parensIf False = id++-- Constants++semi,comma,colon,space,equals :: Doc+semi = return P.semi+comma = return P.comma+colon = return P.colon+space = return P.space+equals = return P.equals++lparen,rparen,lbrack,rbrack,lbrace,rbrace :: Doc+lparen = return P.lparen+rparen = return P.rparen+lbrack = return P.lbrack+rbrack = return P.rbrack+lbrace = return P.lbrace+rbrace = return P.rbrace++-- Combinators++(<>),(<+>),($$),($+$) :: Doc -> Doc -> Doc+aM <> bM = do{a<-aM;b<-bM;return (a P.<> b)}+aM <+> bM = do{a<-aM;b<-bM;return (a P.<+> b)}+aM $$ bM = do{a<-aM;b<-bM;return (a P.$$ b)}+aM $+$ bM = do{a<-aM;b<-bM;return (a P.$+$ b)}++hcat,hsep,vcat,sep,cat,fsep,fcat :: [Doc] -> Doc+hcat dl = sequence dl >>= return . P.hcat+hsep dl = sequence dl >>= return . P.hsep+vcat dl = sequence dl >>= return . P.vcat+sep dl = sequence dl >>= return . P.sep+cat dl = sequence dl >>= return . P.cat+fsep dl = sequence dl >>= return . P.fsep+fcat dl = sequence dl >>= return . P.fcat++-- Some More++hang :: Doc -> Int -> Doc -> Doc+hang dM i rM = do{d<-dM;r<-rM;return $ P.hang d i r}++-- Yuk, had to cut-n-paste this one from Pretty.hs+punctuate :: Doc -> [Doc] -> [Doc]+punctuate _ [] = []+punctuate p (d1:ds) = go d1 ds+ where+ go d [] = [d]+ go d (e:es) = (d <> p) : go e es++-- | render the document with a given style and mode.+renderStyleMode :: P.Style -> PPHsMode -> Doc -> String+renderStyleMode ppStyle ppMode d = P.renderStyle ppStyle . unDocM d $ ppMode++-- | render the document with a given mode.+renderWithMode :: PPHsMode -> Doc -> String+renderWithMode = renderStyleMode P.style++-- | render the document with 'defaultMode'.+render :: Doc -> String+render = renderWithMode defaultMode++-- | pretty-print with a given style and mode.+prettyPrintStyleMode :: Pretty a => P.Style -> PPHsMode -> a -> String+prettyPrintStyleMode ppStyle ppMode = renderStyleMode ppStyle ppMode . pretty++-- | pretty-print with the default style and a given mode.+prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String+prettyPrintWithMode = prettyPrintStyleMode P.style++-- | pretty-print with the default style and 'defaultMode'.+prettyPrint :: Pretty a => a -> String+prettyPrint = prettyPrintWithMode defaultMode++fullRenderWithMode :: PPHsMode -> P.Mode -> Int -> Float ->+ (P.TextDetails -> a -> a) -> a -> Doc -> a+fullRenderWithMode ppMode m i f fn e mD =+ P.fullRender m i f fn e $ (unDocM mD) ppMode+++fullRender :: P.Mode -> Int -> Float -> (P.TextDetails -> a -> a)+ -> a -> Doc -> a+fullRender = fullRenderWithMode defaultMode++------------------------- Pretty-Print a Module --------------------+instance Pretty Module where+ pretty (Module pos m os mbWarn mbExports imp decls) =+ markLine pos $+ myVcat $ map pretty os +++ (if m == ModuleName "" then id+ else \x -> [topLevel (ppModuleHeader m mbWarn mbExports) x])+ (map pretty imp ++ map pretty decls)++-------------------------- Module Header ------------------------------+ppModuleHeader :: ModuleName -> Maybe WarningText -> Maybe [ExportSpec] -> Doc+ppModuleHeader m mbWarn mbExportList = mySep [+ text "module",+ pretty m,+ maybePP ppWarnTxt mbWarn,+ maybePP (parenList . map pretty) mbExportList,+ text "where"]++ppWarnTxt :: WarningText -> Doc+ppWarnTxt (DeprText s) = mySep [text "{-# DEPRECATED", text s, text "#-}"]+ppWarnTxt (WarnText s) = mySep [text "{-# WARNING", text s, text "#-}"]++instance Pretty ModuleName where+ pretty (ModuleName modName) = text modName++instance Pretty ExportSpec where+ pretty (EVar name) = pretty name+ pretty (EAbs name) = pretty name+ pretty (EThingAll name) = pretty name <> text "(..)"+ pretty (EThingWith name nameList) =+ pretty name <> (parenList . map pretty $ nameList)+ pretty (EModuleContents m) = text "module" <+> pretty m++instance Pretty ImportDecl where+ pretty (ImportDecl pos m qual src mbPkg mbName mbSpecs) =+ markLine pos $+ mySep [text "import",+ if src then text "{-# SOURCE #-}" else empty,+ if qual then text "qualified" else empty,+ maybePP (\s -> text (show s)) mbPkg,+ pretty m,+ maybePP (\m' -> text "as" <+> pretty m') mbName,+ maybePP exports mbSpecs]+ where+ exports (b,specList) =+ if b then text "hiding" <+> specs else specs+ where specs = parenList . map pretty $ specList++instance Pretty ImportSpec where+ pretty (IVar name) = pretty name+ pretty (IAbs name) = pretty name+ pretty (IThingAll name) = pretty name <> text "(..)"+ pretty (IThingWith name nameList) =+ pretty name <> (parenList . map pretty $ nameList)++------------------------- Declarations ------------------------------+instance Pretty Decl where+ pretty (TypeDecl loc name nameList htype) =+ blankline $+ markLine loc $+ mySep ( [text "type", pretty name]+ ++ map pretty nameList+ ++ [equals, pretty htype])++ pretty (DataDecl loc don context name nameList constrList derives) =+ blankline $+ markLine loc $+ mySep ( [pretty don, ppContext context, pretty name]+ ++ map pretty nameList)+ <+> (myVcat (zipWith (<+>) (equals : repeat (char '|'))+ (map pretty constrList))+ $$$ ppDeriving derives)++ pretty (GDataDecl loc don context name nameList optkind gadtList derives) =+ blankline $+ markLine loc $+ mySep ( [pretty don, ppContext context, pretty name]+ ++ map pretty nameList ++ ppOptKind optkind ++ [text "where"])+ $$$ ppBody classIndent (map pretty gadtList)+ $$$ ppBody letIndent [ppDeriving derives]++ pretty (TypeFamDecl loc name nameList optkind) =+ blankline $+ markLine loc $+ mySep ([text "type", text "family", pretty name]+ ++ map pretty nameList+ ++ ppOptKind optkind)++ pretty (DataFamDecl loc context name nameList optkind) =+ blankline $+ markLine loc $+ mySep ( [text "data", text "family", ppContext context, pretty name]+ ++ map pretty nameList ++ ppOptKind optkind)++ pretty (TypeInsDecl loc ntype htype) =+ blankline $+ markLine loc $+ mySep [text "type", text "instance", pretty ntype, equals, pretty htype]++ pretty (DataInsDecl loc don ntype constrList derives) =+ blankline $+ markLine loc $+ mySep [pretty don, text "instance", pretty ntype]+ <+> (myVcat (zipWith (<+>) (equals : repeat (char '|'))+ (map pretty constrList))+ $$$ ppDeriving derives)++ pretty (GDataInsDecl loc don ntype optkind gadtList derives) =+ blankline $+ markLine loc $+ mySep ( [pretty don, text "instance", pretty ntype]+ ++ ppOptKind optkind ++ [text "where"])+ $$$ ppBody classIndent (map pretty gadtList)+ $$$ ppDeriving derives++ --m{spacing=False}+ -- special case for empty class declaration+ pretty (ClassDecl pos context name nameList fundeps []) =+ blankline $+ markLine pos $+ mySep ( [text "class", ppContext context, pretty name]+ ++ map pretty nameList ++ [ppFunDeps fundeps])+ pretty (ClassDecl pos context name nameList fundeps declList) =+ blankline $+ markLine pos $+ mySep ( [text "class", ppContext context, pretty name]+ ++ map pretty nameList ++ [ppFunDeps fundeps, text "where"])+ $$$ ppBody classIndent (map pretty declList)++ -- m{spacing=False}+ -- special case for empty instance declaration+ pretty (InstDecl pos context name args []) =+ blankline $+ markLine pos $+ mySep ( [text "instance", ppContext context, pretty name]+ ++ map ppAType args)+ pretty (InstDecl pos context name args declList) =+ blankline $+ markLine pos $+ mySep ( [text "instance", ppContext context, pretty name]+ ++ map ppAType args ++ [text "where"])+ $$$ ppBody classIndent (map pretty declList)++ pretty (DerivDecl pos context name args) =+ blankline $+ markLine pos $+ mySep ( [text "deriving", text "instance", ppContext context, pretty name]+ ++ map ppAType args)+ pretty (DefaultDecl pos htypes) =+ blankline $+ markLine pos $+ text "default" <+> parenList (map pretty htypes)++ pretty (SpliceDecl pos splice) =+ blankline $+ markLine pos $+ pretty splice++ pretty (TypeSig pos nameList qualType) =+ blankline $+ markLine pos $+ mySep ((punctuate comma . map pretty $ nameList)+ ++ [text "::", pretty qualType])++ pretty (FunBind matches) = do+ e <- fmap layout getPPEnv+ case e of PPOffsideRule -> foldr ($$$) empty (map pretty matches)+ _ -> foldr (\x y -> x <> semi <> y) empty (map pretty matches)++ pretty (PatBind pos pat optsig rhs whereBinds) =+ markLine pos $+ myFsep [pretty pat, maybePP ppSig optsig, pretty rhs] $$$ ppWhere whereBinds++ pretty (InfixDecl pos assoc prec opList) =+ blankline $+ markLine pos $+ mySep ([pretty assoc, int prec]+ ++ (punctuate comma . map pretty $ opList))++ pretty (ForImp pos cconv saf str name typ) =+ blankline $+ markLine pos $+ mySep [text "foreign import", pretty cconv, pretty saf,+ text (show str), pretty name, text "::", pretty typ]++ pretty (ForExp pos cconv str name typ) =+ blankline $+ markLine pos $+ mySep [text "foreign export", pretty cconv,+ text (show str), pretty name, text "::", pretty typ]++ pretty (RulePragmaDecl pos rules) =+ blankline $+ markLine pos $+ myVcat $ text "{-# RULES" : map pretty rules ++ [text " #-}"]++ pretty (DeprPragmaDecl pos deprs) =+ blankline $+ markLine pos $+ myVcat $ text "{-# DEPRECATED" : map ppWarnDepr deprs ++ [text " #-}"]++ pretty (WarnPragmaDecl pos deprs) =+ blankline $+ markLine pos $+ myVcat $ text "{-# WARNING" : map ppWarnDepr deprs ++ [text " #-}"]++ pretty (InlineSig pos inl activ name) =+ blankline $+ markLine pos $+ mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"]++ pretty (InlineConlikeSig pos activ name) =+ blankline $+ markLine pos $+ mySep [text "{-# INLINE_CONLIKE", pretty activ, pretty name, text "#-}"]++ pretty (SpecSig pos name types) =+ blankline $+ markLine pos $+ mySep $ [text "{-# SPECIALISE", pretty name, text "::"]+ ++ punctuate comma (map pretty types) ++ [text "#-}"]++ pretty (SpecInlineSig pos inl activ name types) =+ blankline $+ markLine pos $+ mySep $ [text "{-# SPECIALISE", text (if inl then "INLINE" else "NOINLINE"),+ pretty activ, pretty name, text "::"]+ ++ (punctuate comma $ map pretty types) ++ [text "#-}"]++ pretty (InstSig pos context name args) =+ blankline $+ markLine pos $+ mySep $ [text "{-# SPECIALISE", text "instance", ppContext context, pretty name]+ ++ map ppAType args ++ [text "#-}"]++ pretty (AnnPragma pos ann) =+ blankline $+ markLine pos $+ mySep $ [text "{-# ANN", pretty ann, text "#-}"]++instance Pretty Annotation where+ pretty (Ann n e) = myFsep [pretty n, pretty e]+ pretty (TypeAnn n e) = myFsep [text "type", pretty n, pretty e]+ pretty (ModuleAnn e) = myFsep [text "module", pretty e]++instance Pretty DataOrNew where+ pretty DataType = text "data"+ pretty NewType = text "newtype"++instance Pretty Assoc where+ pretty AssocNone = text "infix"+ pretty AssocLeft = text "infixl"+ pretty AssocRight = text "infixr"++instance Pretty Match where+ pretty (Match pos f ps optsig rhs whereBinds) =+ markLine pos $+ myFsep (lhs ++ [maybePP ppSig optsig, pretty rhs])+ $$$ ppWhere whereBinds+ where+ lhs = case ps of+ l:r:ps' | isSymbolName f ->+ let hd = [pretty l, ppName f, pretty r] in+ if null ps' then hd+ else parens (myFsep hd) : map (prettyPrec 2) ps'+ _ -> pretty f : map (prettyPrec 2) ps++ppWhere :: Binds -> Doc+ppWhere (BDecls []) = empty+ppWhere (BDecls l) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l))+ppWhere (IPBinds b) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty b))++ppSig :: Type -> Doc+ppSig t = text "::" <+> pretty t++instance Pretty ClassDecl where+ pretty (ClsDecl decl) = pretty decl++ pretty (ClsDataFam loc context name nameList optkind) =+ markLine loc $+ mySep ( [text "data", ppContext context, pretty name]+ ++ map pretty nameList ++ ppOptKind optkind)++ pretty (ClsTyFam loc name nameList optkind) =+ markLine loc $+ mySep ( [text "type", pretty name]+ ++ map pretty nameList ++ ppOptKind optkind)++ pretty (ClsTyDef loc ntype htype) =+ markLine loc $+ mySep [text "type", pretty ntype, equals, pretty htype]++instance Pretty InstDecl where+ pretty (InsDecl decl) = pretty decl++ pretty (InsType loc ntype htype) =+ markLine loc $+ mySep [text "type", pretty ntype, equals, pretty htype]++ pretty (InsData loc don ntype constrList derives) =+ markLine loc $+ mySep [pretty don, pretty ntype]+ <+> (myVcat (zipWith (<+>) (equals : repeat (char '|'))+ (map pretty constrList))+ $$$ ppDeriving derives)++ pretty (InsGData loc don ntype optkind gadtList derives) =+ markLine loc $+ mySep ( [pretty don, pretty ntype]+ ++ ppOptKind optkind ++ [text "where"])+ $$$ ppBody classIndent (map pretty gadtList)+ $$$ ppDeriving derives++-- pretty (InsInline loc inl activ name) =+-- markLine loc $+-- mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"]+++------------------------- FFI stuff -------------------------------------+instance Pretty Safety where+ pretty PlayRisky = text "unsafe"+ pretty (PlaySafe b) = text $ if b then "threadsafe" else "safe"++instance Pretty CallConv where+ pretty StdCall = text "stdcall"+ pretty CCall = text "ccall"++------------------------- Pragmas ---------------------------------------+ppWarnDepr :: ([Name], String) -> Doc+ppWarnDepr (names, txt) = mySep $ (punctuate comma $ map pretty names) ++ [text $ show txt]++instance Pretty Rule where+ pretty (Rule tag activ rvs rhs lhs) =+ mySep $ [text $ show tag, pretty activ,+ maybePP ppRuleVars rvs,+ pretty rhs, char '=', pretty lhs]++ppRuleVars :: [RuleVar] -> Doc+ppRuleVars [] = empty+ppRuleVars rvs = mySep $ text "forall" : map pretty rvs ++ [char '.']++instance Pretty Activation where+ pretty AlwaysActive = empty+ pretty (ActiveFrom i) = char '[' <> int i <> char ']'+ pretty (ActiveUntil i) = text "[~" <> int i <> char ']'++instance Pretty RuleVar where+ pretty (RuleVar n) = pretty n+ pretty (TypedRuleVar n t) = parens $ mySep [pretty n, text "::", pretty t]++instance Pretty ModulePragma where+ pretty (LanguagePragma _ ns) =+ myFsep $ text "{-# LANGUAGE" : punctuate (char ',') (map pretty ns) ++ [text "#-}"]+ pretty (OptionsPragma _ (Just tool) s) =+ myFsep $ [text "{-# OPTIONS_" <> pretty tool, text s, text "#-}"]+ pretty (OptionsPragma _ _ s) =+ myFsep $ [text "{-# OPTIONS", text s, text "#-}"]+ pretty (AnnModulePragma _ ann) =+ myFsep $ [text "{-# ANN", pretty ann, text "#-}"]+ ++instance Pretty Tool where+ pretty (UnknownTool s) = text s+ pretty t = text $ show t++------------------------- Data & Newtype Bodies -------------------------+instance Pretty QualConDecl where+ pretty (QualConDecl _pos tvs ctxt con) =+ myFsep [ppForall (Just tvs), ppContext ctxt, pretty con]++instance Pretty GadtDecl where+ pretty (GadtDecl _pos name ty) =+ myFsep [pretty name, text "::", pretty ty]++instance Pretty ConDecl where+ pretty (RecDecl name fieldList) =+ pretty name <> (braceList . map ppField $ fieldList)++{- pretty (ConDecl name@(Symbol _) [l, r]) =+ myFsep [prettyPrec prec_btype l, ppName name,+ prettyPrec prec_btype r] -}+ pretty (ConDecl name typeList) =+ mySep $ ppName name : map (prettyPrec prec_atype) typeList+ pretty (InfixConDecl l name r) =+ myFsep [prettyPrec prec_btype l, ppNameInfix name,+ prettyPrec prec_btype r]++ppField :: ([Name],BangType) -> Doc+ppField (names, ty) =+ myFsepSimple $ (punctuate comma . map pretty $ names) +++ [text "::", pretty ty]++instance Pretty BangType where+ prettyPrec _ (BangedTy ty) = char '!' <> ppAType ty+ prettyPrec p (UnBangedTy ty) = prettyPrec p ty+ prettyPrec p (UnpackedTy ty) = text "{-# UNPACK #-}" <+> char '!' <> prettyPrec p ty++ppDeriving :: [Deriving] -> Doc+ppDeriving [] = empty+ppDeriving [(d, [])] = text "deriving" <+> ppQName d+ppDeriving ds = text "deriving" <+> parenList (map ppDer ds)+ where ppDer :: (QName, [Type]) -> Doc+ ppDer (n, ts) = mySep (pretty n : map pretty ts)++------------------------- Types -------------------------+ppBType :: Type -> Doc+ppBType = prettyPrec prec_btype++ppAType :: Type -> Doc+ppAType = prettyPrec prec_atype++-- precedences for types+prec_btype, prec_atype :: Int+prec_btype = 1 -- left argument of ->,+ -- or either argument of an infix data constructor+prec_atype = 2 -- argument of type or data constructor, or of a class++instance Pretty Type where+ prettyPrec p (TyForall mtvs ctxt htype) = parensIf (p > 0) $+ myFsep [ppForall mtvs, ppContext ctxt, pretty htype]+ prettyPrec p (TyFun a b) = parensIf (p > 0) $+ myFsep [ppBType a, text "->", pretty b]+ prettyPrec _ (TyTuple bxd l) =+ let ds = map pretty l+ in case bxd of+ Boxed -> parenList ds+ Unboxed -> hashParenList ds+ prettyPrec _ (TyList t) = brackets $ pretty t+ prettyPrec p (TyApp a b) =+ {-+ | a == list_tycon = brackets $ pretty b -- special case+ | otherwise = -} parensIf (p > prec_btype) $+ myFsep [pretty a, ppAType b]+ prettyPrec _ (TyVar name) = pretty name+ prettyPrec _ (TyCon name) = pretty name+ prettyPrec _ (TyParen t) = parens (pretty t)+-- prettyPrec _ (TyPred asst) = pretty asst+ prettyPrec _ (TyInfix a op b) = myFsep [pretty a, ppQNameInfix op, pretty b]+ prettyPrec _ (TyKind t k) = parens (myFsep [pretty t, text "::", pretty k])+++instance Pretty TyVarBind where+ pretty (KindedVar var kind) = parens $ myFsep [pretty var, text "::", pretty kind]+ pretty (UnkindedVar var) = pretty var++ppForall :: Maybe [TyVarBind] -> Doc+ppForall Nothing = empty+ppForall (Just []) = empty+ppForall (Just vs) = myFsep (text "forall" : map pretty vs ++ [char '.'])++---------------------------- Kinds ----------------------------++instance Pretty Kind where+ prettyPrec _ KindStar = text "*"+ prettyPrec _ KindBang = text "!"+ prettyPrec n (KindFn a b) = parensIf (n > 0) $ myFsep [prettyPrec 1 a, text "->", pretty b]+ prettyPrec _ (KindParen k) = parens $ pretty k+ prettyPrec _ (KindVar n) = pretty n++ppOptKind :: Maybe Kind -> [Doc]+ppOptKind Nothing = []+ppOptKind (Just k) = [text "::", pretty k]++------------------- Functional Dependencies -------------------+instance Pretty FunDep where+ pretty (FunDep from to) =+ myFsep $ map pretty from ++ [text "->"] ++ map pretty to+++ppFunDeps :: [FunDep] -> Doc+ppFunDeps [] = empty+ppFunDeps fds = myFsep $ (char '|':) . punctuate comma . map pretty $ fds++------------------------- Expressions -------------------------+instance Pretty Rhs where+ pretty (UnGuardedRhs e) = equals <+> pretty e+ pretty (GuardedRhss guardList) = myVcat . map pretty $ guardList++instance Pretty GuardedRhs where+ pretty (GuardedRhs _pos guards ppBody) =+ myFsep $ [char '|'] ++ (punctuate comma . map pretty $ guards) ++ [equals, pretty ppBody]++instance Pretty Literal where+ pretty (Int i) = integer i+ pretty (Char c) = text (show c)+ pretty (String s) = text (show s)+ pretty (Frac r) = double (fromRational r)+ -- GHC unboxed literals:+ pretty (PrimChar c) = text (show c) <> char '#'+ pretty (PrimString s) = text (show s) <> char '#'+ pretty (PrimInt i) = integer i <> char '#'+ pretty (PrimWord w) = integer w <> text "##"+ pretty (PrimFloat r) = float (fromRational r) <> char '#'+ pretty (PrimDouble r) = double (fromRational r) <> text "##"++instance Pretty Exp where+ prettyPrec _ FreeSectSlot = text "__"+ prettyPrec _ (Lit l) = pretty l+ -- lambda stuff+ prettyPrec p (InfixApp a op b) = parensIf (p > 2) $ myFsep [prettyPrec 2 a, pretty op, prettyPrec 1 b]+ prettyPrec p (NegApp e) = parensIf (p > 0) $ char '-' <> prettyPrec 4 e+ prettyPrec p (App a b) = parensIf (p > 3) $ myFsep [prettyPrec 3 a, prettyPrec 4 b]+ prettyPrec p (Lambda _loc patList ppBody) = parensIf (p > 1) $ myFsep $+ char '\\' : map pretty patList ++ [text "->", pretty ppBody]+ -- keywords+ -- two cases for lets+ prettyPrec p (Let (BDecls declList) letBody) =+ parensIf (p > 1) $ ppLetExp declList letBody+ prettyPrec p (Let (IPBinds bindList) letBody) =+ parensIf (p > 1) $ ppLetExp bindList letBody++ prettyPrec p (If cond thenexp elsexp) = parensIf (p > 1) $+ myFsep [text "if", pretty cond,+ text "then", pretty thenexp,+ text "else", pretty elsexp]+ prettyPrec p (Case cond altList) = parensIf (p > 1) $+ myFsep [text "case", pretty cond, text "of"]+ $$$ ppBody caseIndent (map pretty altList)+ prettyPrec p (Do stmtList) = parensIf (p > 1) $ + text "do" $$$ ppBody doIndent (map pretty stmtList)+ prettyPrec p (MDo stmtList) = parensIf (p > 1) $ + text "mdo" $$$ ppBody doIndent (map pretty stmtList)+ -- Constructors & Vars+ prettyPrec _ (Var name) = pretty name+ prettyPrec _ (IPVar ipname) = pretty ipname+ prettyPrec _ (Con name) = pretty name+ prettyPrec _ (Tuple expList) = parenList . map pretty $ expList+ prettyPrec _ (TupleSection mExpList) = parenList . map (maybePP pretty) $ mExpList+ -- weird stuff+-- prettyPrec _ (FSContext e) = fscontexts . pretty $ e+ prettyPrec _ (FSContext e) = myFsep $ [text "_[", pretty e, text "]_"]+ prettyPrec _ (Paren e) = parens . pretty $ e+ prettyPrec _ (LeftSection e op) = parens (pretty e <+> pretty op)+ prettyPrec _ (RightSection op e) = parens (pretty op <+> pretty e)+ prettyPrec _ (RecConstr c fieldList) =+ pretty c <> (braceList . map pretty $ fieldList)+ prettyPrec _ (RecUpdate e fieldList) =+ pretty e <> (braceList . map pretty $ fieldList)+ -- Lists+ prettyPrec _ (List list) =+ bracketList . punctuate comma . map pretty $ list+ prettyPrec _ (EnumFrom e) =+ bracketList [pretty e, text ".."]+ prettyPrec _ (EnumFromTo from to) =+ bracketList [pretty from, text "..", pretty to]+ prettyPrec _ (EnumFromThen from thenE) =+ bracketList [pretty from <> comma, pretty thenE, text ".."]+ prettyPrec _ (EnumFromThenTo from thenE to) =+ bracketList [pretty from <> comma, pretty thenE,+ text "..", pretty to]+ prettyPrec _ (ListComp e qualList) =+ bracketList ([pretty e, char '|']+ ++ (punctuate comma . map pretty $ qualList))+ prettyPrec _ (ParComp e qualLists) =+ bracketList (intersperse (char '|') $+ pretty e : (punctuate comma . concatMap (map pretty) $ qualLists))+ prettyPrec p (ExpTypeSig _pos e ty) = parensIf (p > 0) $ + myFsep [pretty e, text "::", pretty ty]+ -- Template Haskell+ prettyPrec _ (BracketExp b) = pretty b+ prettyPrec _ (SpliceExp s) = pretty s+ prettyPrec _ (TypQuote t) = text "\'\'" <> pretty t+ prettyPrec _ (VarQuote x) = text "\'" <> pretty x+ prettyPrec _ (QuasiQuote n qt) = text ("[$" ++ n ++ "|" ++ qt ++ "|]")+ -- Hsx+ prettyPrec _ (XTag _ n attrs mattr cs) =+ let ax = maybe [] (return . pretty) mattr+ in hcat $+ (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [char '>']):+ map pretty cs ++ [myFsep $ [text "</" <> pretty n, char '>']]+ prettyPrec _ (XETag _ n attrs mattr) =+ let ax = maybe [] (return . pretty) mattr+ in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"]+ prettyPrec _ (XPcdata s) = text s+ prettyPrec _ (XExpTag e) =+ myFsep $ [text "<%", pretty e, text "%>"]+ prettyPrec _ (XChildTag _ cs) =+ myFsep $ text "<%>" : map pretty cs ++ [text "</%>"]+ + -- Pragmas+ prettyPrec p (CorePragma s e) = myFsep $ map text ["{-# CORE", show s, "#-}"] ++ [pretty e]+ prettyPrec _ (SCCPragma s e) = myFsep $ map text ["{-# SCC", show s, "#-}"] ++ [pretty e]+ prettyPrec _ (GenPragma s (a,b) (c,d) e) =+ myFsep $ [text "{-# GENERATED", text $ show s,+ int a, char ':', int b, char '-',+ int c, char ':', int d, text "#-}", pretty e]+ -- Arrows+ prettyPrec p (Proc _ pat e) = parensIf (p > 1) $ myFsep $ [text "proc", pretty pat, text "->", pretty e]+ prettyPrec p (LeftArrApp l r) = parensIf (p > 0) $ myFsep $ [pretty l, text "-<", pretty r]+ prettyPrec p (RightArrApp l r) = parensIf (p > 0) $ myFsep $ [pretty l, text ">-", pretty r]+ prettyPrec p (LeftArrHighApp l r) = parensIf (p > 0) $ myFsep $ [pretty l, text "-<<", pretty r]+ prettyPrec p (RightArrHighApp l r) = parensIf (p > 0) $ myFsep $ [pretty l, text ">>-", pretty r]+++instance Pretty XAttr where+ pretty (XAttr n v) =+ myFsep [pretty n, char '=', pretty v]++instance Pretty XName where+ pretty (XName n) = text n+ pretty (XDomName d n) = text d <> char ':' <> text n++--ppLetExp :: [Decl] -> Exp -> Doc+ppLetExp l b = myFsep [text "let" <+> ppBody letIndent (map pretty l),+ text "in", pretty b]++ppWith binds = nest 2 (text "with" $$$ ppBody withIndent (map pretty binds))+withIndent = whereIndent++--------------------- Template Haskell -------------------------++instance Pretty Bracket where+ pretty (ExpBracket e) = ppBracket "[|" e+ pretty (PatBracket p) = ppBracket "[p|" p+ pretty (TypeBracket t) = ppBracket "[t|" t+ pretty (DeclBracket d) =+ myFsep $ text "[d|" : map pretty d ++ [text "|]"]++ppBracket o x = myFsep [text o, pretty x, text "|]"]++instance Pretty Splice where+ pretty (IdSplice s) = char '$' <> text s+ pretty (ParenSplice e) =+ myFsep [text "$(", pretty e, char ')']++------------------------- Patterns -----------------------------++instance Pretty Pat where+ prettyPrec _ (PVar name) = pretty name+ prettyPrec _ (PLit lit) = pretty lit+ prettyPrec p (PNeg pat) = parensIf (p > 0) $ myFsep [char '-', pretty pat]+ prettyPrec p (PInfixApp a op b) = parensIf (p > 0) $+ myFsep [prettyPrec 1 a, pretty (QConOp op), prettyPrec 1 b]+ prettyPrec p (PApp n ps) = parensIf (p > 1 && not (null ps)) $+ myFsep (pretty n : map (prettyPrec 2) ps)+ prettyPrec _ (PTuple ps) = parenList . map pretty $ ps+ prettyPrec _ (PList ps) =+ bracketList . punctuate comma . map pretty $ ps+ prettyPrec _ (PParen pat) = parens . pretty $ pat+ prettyPrec _ (PRec c fields) =+ pretty c <> (braceList . map pretty $ fields)+ -- special case that would otherwise be buggy+ prettyPrec _ (PAsPat name (PIrrPat pat)) =+ myFsep [pretty name <> char '@', char '~' <> prettyPrec 2 pat]+ prettyPrec _ (PAsPat name pat) =+ hcat [pretty name, char '@', prettyPrec 2 pat]+ prettyPrec _ PWildCard = char '_'+ prettyPrec _ (PIrrPat pat) = char '~' <> prettyPrec 2 pat+ prettyPrec p (PatTypeSig _pos pat ty) = parensIf (p > 0) $+ myFsep [pretty pat, text "::", pretty ty]+ prettyPrec p (PViewPat e pat) = parensIf (p > 0) $+ myFsep [pretty e, text "->", pretty pat]+ prettyPrec p (PNPlusK n k) = parensIf (p > 0) $+ myFsep [pretty n, text "+", text $ show k]+ -- HaRP+ prettyPrec _ (PRPat rs) =+ bracketList . punctuate comma . map pretty $ rs+ -- Hsx+ prettyPrec _ (PXTag _ n attrs mattr cp) =+ let ap = maybe [] (return . pretty) mattr+ in hcat $ -- TODO: should not introduce blanks+ (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [char '>']):+ map pretty cp ++ [myFsep $ [text "</" <> pretty n, char '>']]+ prettyPrec _ (PXETag _ n attrs mattr) =+ let ap = maybe [] (return . pretty) mattr+ in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [text "/>"]+ prettyPrec _ (PXPcdata s) = text s+ prettyPrec _ (PXPatTag p) =+ myFsep $ [text "<%", pretty p, text "%>"]+ prettyPrec _ (PXRPats ps) =+ myFsep $ text "<[" : map pretty ps ++ [text "%>"]+ -- Generics+ prettyPrec _ (PExplTypeArg qn t) =+ myFsep [pretty qn, text "{|", pretty t, text "|}"]+ -- BangPatterns+ prettyPrec _ (PBangPat pat) = text "!" <> prettyPrec 2 pat++instance Pretty PXAttr where+ pretty (PXAttr n p) =+ myFsep [pretty n, char '=', pretty p]++instance Pretty PatField where+ pretty (PFieldPat name pat) =+ myFsep [pretty name, equals, pretty pat]+ pretty (PFieldPun name) = pretty name+ pretty (PFieldWildcard) = text ".."++--------------------- Regular Patterns -------------------------++instance Pretty RPat where+ pretty (RPOp r op) = pretty r <> pretty op+ pretty (RPEither r1 r2) = parens . myFsep $+ [pretty r1, char '|', pretty r2]+ pretty (RPSeq rs) =+ myFsep $ text "(/" : map pretty rs ++ [text "/)"]+ pretty (RPGuard r gs) =+ myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"]+ -- special case that would otherwise be buggy+ pretty (RPCAs n (RPPat (PIrrPat p))) =+ myFsep [pretty n <> text "@:", char '~' <> pretty p]+ pretty (RPCAs n r) = hcat [pretty n, text "@:", pretty r]+ -- special case that would otherwise be buggy+ pretty (RPAs n (RPPat (PIrrPat p))) =+ myFsep [pretty n <> text "@:", char '~' <> pretty p]+ pretty (RPAs n r) = hcat [pretty n, char '@', pretty r]+ pretty (RPPat p) = pretty p+ pretty (RPParen rp) = parens . pretty $ rp++instance Pretty RPatOp where+ pretty RPStar = char '*'+ pretty RPStarG = text "*!"+ pretty RPPlus = char '+'+ pretty RPPlusG = text "+!"+ pretty RPOpt = char '?'+ pretty RPOptG = text "?!"++------------------------- Case bodies -------------------------+instance Pretty Alt where+ pretty (Alt _pos e gAlts binds) =+ pretty e <+> pretty gAlts $$$ ppWhere binds++instance Pretty GuardedAlts where+ pretty (UnGuardedAlt e) = text "->" <+> pretty e+ pretty (GuardedAlts altList) = myVcat . map pretty $ altList++instance Pretty GuardedAlt where+ pretty (GuardedAlt _pos guards body) =+ myFsep $ char '|': (punctuate comma . map pretty $ guards) ++ [text "->", pretty body]++------------------------- Statements in monads, guards & list comprehensions -----+instance Pretty Stmt where+ pretty (Generator _loc e from) =+ pretty e <+> text "<-" <+> pretty from+ pretty (Qualifier e) = pretty e+ -- two cases for lets+ pretty (LetStmt (BDecls declList)) =+ ppLetStmt declList+ pretty (LetStmt (IPBinds bindList)) =+ ppLetStmt bindList+ pretty (RecStmt stmtList) =+ text "rec" $$$ ppBody letIndent (map pretty stmtList)++ppLetStmt l = text "let" $$$ ppBody letIndent (map pretty l)++instance Pretty QualStmt where+ pretty (QualStmt s) = pretty s+ pretty (ThenTrans f) = myFsep $ [text "then", pretty f]+ pretty (ThenBy f e) = myFsep $ [text "then", pretty f, text "by", pretty e]+ pretty (GroupBy e) = myFsep $ [text "then", text "group", text "by", pretty e]+ pretty (GroupUsing f) = myFsep $ [text "then", text "group", text "using", pretty f]+ pretty (GroupByUsing e f) = myFsep $ [text "then", text "group", text "by",+ pretty e, text "using", pretty f]++++------------------------- Record updates+instance Pretty FieldUpdate where+ pretty (FieldUpdate name e) =+ myFsep [pretty name, equals, pretty e]+ pretty (FieldPun name) = pretty name+ pretty (FieldWildcard) = text ".."++------------------------- Names -------------------------+instance Pretty QOp where+ pretty (QVarOp n) = ppQNameInfix n+ pretty (QConOp n) = ppQNameInfix n++ppQNameInfix :: QName -> Doc+ppQNameInfix name+ | isSymbolName (getName name) = ppQName name+ | otherwise = char '`' <> ppQName name <> char '`'++instance Pretty QName where+ pretty name = case name of+ UnQual (Symbol ('#':_)) -> char '(' <+> ppQName name <+> char ')'+ _ -> parensIf (isSymbolName (getName name)) (ppQName name)++ppQName :: QName -> Doc+ppQName (UnQual name) = ppName name+ppQName (Qual m name) = pretty m <> char '.' <> ppName name+ppQName (Special sym) = text (specialName sym)++instance Pretty Op where+ pretty (VarOp n) = ppNameInfix n+ pretty (ConOp n) = ppNameInfix n++ppNameInfix :: Name -> Doc+ppNameInfix name+ | isSymbolName name = ppName name+ | otherwise = char '`' <> ppName name <> char '`'++instance Pretty Name where+ pretty name = case name of+ Symbol ('#':_) -> char '(' <+> ppName name <+> char ')'+ _ -> parensIf (isSymbolName name) (ppName name)++ppName :: Name -> Doc+ppName (Ident s) = text s+ppName (Symbol s) = text s++instance Pretty IPName where+ pretty (IPDup s) = char '?' <> text s+ pretty (IPLin s) = char '%' <> text s++instance Pretty IPBind where+ pretty (IPBind _loc ipname exp) =+ myFsep [pretty ipname, equals, pretty exp]++instance Pretty CName where+ pretty (VarName n) = pretty n+ pretty (ConName n) = pretty n++instance Pretty SpecialCon where+ pretty sc = text $ specialName sc++isSymbolName :: Name -> Bool+isSymbolName (Symbol _) = True+isSymbolName _ = False++getName :: QName -> Name+getName (UnQual s) = s+getName (Qual _ s) = s+getName (Special Cons) = Symbol ":"+getName (Special FunCon) = Symbol "->"+getName (Special s) = Ident (specialName s)++specialName :: SpecialCon -> String+specialName UnitCon = "()"+specialName ListCon = "[]"+specialName FunCon = "->"+specialName (TupleCon b n) = "(" ++ hash ++ replicate (n-1) ',' ++ hash ++ ")"+ where hash = if b == Unboxed then "#" else ""+specialName Cons = ":"++ppContext :: Context -> Doc+ppContext [] = empty+ppContext context = mySep [parenList (map pretty context), text "=>"]++-- hacked for multi-parameter type classes+instance Pretty Asst where+ pretty (ClassA a ts) = myFsep $ ppQName a : map ppAType ts+ pretty (InfixA a op b) = myFsep $ [pretty a, ppQNameInfix op, pretty b]+ pretty (IParam i t) = myFsep $ [pretty i, text "::", pretty t]+ pretty (EqualP t1 t2) = myFsep $ [pretty t1, text "~", pretty t2]++-- Pretty print a source location, useful for printing out error messages+instance Pretty SrcLoc where+ pretty srcLoc =+ return $ P.hsep [ colonFollow (P.text $ srcFilename srcLoc)+ , colonFollow (P.int $ srcLine srcLoc)+ , P.int $ srcColumn srcLoc+ ]++colonFollow p = P.hcat [ p, P.colon ]+++instance Pretty SrcSpan where+ pretty srcSpan =+ return $ P.hsep [ colonFollow (P.text $ srcSpanFilename srcSpan)+ , P.hcat [ P.text "("+ , P.int $ srcSpanStartLine srcSpan+ , P.colon+ , P.int $ srcSpanStartColumn srcSpan+ , P.text ")"+ ]+ , P.text "-"+ , P.hcat [ P.text "("+ , P.int $ srcSpanEndLine srcSpan+ , P.colon+ , P.int $ srcSpanEndColumn srcSpan+ , P.text ")"+ ]+ ]++---------------------------------------------------------------------+-- Annotated version++------------------------- Pretty-Print a Module --------------------+instance SrcInfo pos => Pretty (A.Module pos) where+ pretty (A.Module pos mbHead os imp decls) =+ markLine pos $+ myVcat $ map pretty os +++ (case mbHead of+ Nothing -> id+ Just h -> \x -> [topLevel (pretty h) x])+ (map pretty imp ++ map pretty decls)+ pretty (A.XmlPage pos _mn os n attrs mattr cs) =+ markLine pos $+ myVcat $ map pretty os +++ [let ax = maybe [] (return . pretty) mattr+ in hcat $+ (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [char '>']):+ map pretty cs ++ [myFsep $ [text "</" <> pretty n, char '>']]]+ pretty (A.XmlHybrid pos mbHead os imp decls n attrs mattr cs) =+ markLine pos $+ myVcat $ map pretty os ++ [text "<%"] +++ (case mbHead of+ Nothing -> id+ Just h -> \x -> [topLevel (pretty h) x])+ (map pretty imp ++ map pretty decls +++ [let ax = maybe [] (return . pretty) mattr+ in hcat $+ (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [char '>']):+ map pretty cs ++ [myFsep $ [text "</" <> pretty n, char '>']]])++++-------------------------- Module Header ------------------------------+instance Pretty (A.ModuleHead l) where+ pretty (A.ModuleHead _ m mbWarn mbExportList) = mySep [+ text "module",+ pretty m,+ maybePP pretty mbWarn,+ maybePP pretty mbExportList,+ text "where"]++instance Pretty (A.WarningText l) where+ pretty = ppWarnTxt. sWarningText++instance Pretty (A.ModuleName l) where+ pretty = pretty . sModuleName++instance Pretty (A.ExportSpecList l) where+ pretty (A.ExportSpecList _ especs) = parenList $ map pretty especs++instance Pretty (A.ExportSpec l) where+ pretty = pretty . sExportSpec++instance SrcInfo pos => Pretty (A.ImportDecl pos) where+ pretty = pretty . sImportDecl++instance Pretty (A.ImportSpecList l) where+ pretty (A.ImportSpecList _ b ispecs) =+ (if b then text "hiding" else empty)+ <+> parenList (map pretty ispecs)++instance Pretty (A.ImportSpec l) where+ pretty = pretty . sImportSpec++------------------------- Declarations ------------------------------+instance SrcInfo pos => Pretty (A.Decl pos) where+ pretty = pretty . sDecl++instance Pretty (A.DeclHead l) where+ pretty (A.DHead l n tvs) = mySep (pretty n : map pretty tvs)+ pretty (A.DHInfix l tva n tvb) = mySep [pretty tva, pretty n, pretty tvb]+ pretty (A.DHParen l dh) = parens (pretty dh)++instance Pretty (A.InstHead l) where+ pretty (A.IHead l qn ts) = mySep (pretty qn : map pretty ts)+ pretty (A.IHInfix l ta qn tb) = mySep [pretty ta, pretty qn, pretty tb]+ pretty (A.IHParen l ih) = parens (pretty ih)++instance Pretty (A.DataOrNew l) where+ pretty = pretty . sDataOrNew++instance Pretty (A.Assoc l) where+ pretty = pretty . sAssoc++instance SrcInfo pos => Pretty (A.Match pos) where+ pretty = pretty . sMatch++instance SrcInfo loc => Pretty (A.ClassDecl loc) where+ pretty = pretty . sClassDecl++instance SrcInfo loc => Pretty (A.InstDecl loc) where+ pretty = pretty . sInstDecl++------------------------- FFI stuff -------------------------------------+instance Pretty (A.Safety l) where+ pretty = pretty . sSafety++instance Pretty (A.CallConv l) where+ pretty = pretty . sCallConv++------------------------- Pragmas ---------------------------------------+instance SrcInfo loc => Pretty (A.Rule loc) where+ pretty = pretty . sRule++instance Pretty (A.Activation l) where+ pretty = pretty . sActivation++instance Pretty (A.RuleVar l) where+ pretty = pretty . sRuleVar++instance SrcInfo loc => Pretty (A.ModulePragma loc) where+ pretty (A.LanguagePragma _ ns) =+ myFsep $ text "{-# LANGUAGE" : punctuate (char ',') (map pretty ns) ++ [text "#-}"]+ pretty (A.OptionsPragma _ (Just tool) s) =+ myFsep $ [text "{-# OPTIONS_" <> pretty tool, text s, text "#-}"]+ pretty (A.OptionsPragma _ _ s) =+ myFsep $ [text "{-# OPTIONS", text s, text "#-}"]+ pretty (A.AnnModulePragma _ ann) =+ myFsep $ [text "{-# ANN", pretty ann, text "#-}"]++instance SrcInfo loc => Pretty (A.Annotation loc) where+ pretty = pretty . sAnnotation++------------------------- Data & Newtype Bodies -------------------------+instance Pretty (A.QualConDecl l) where+ pretty (A.QualConDecl _pos mtvs ctxt con) =+ myFsep [ppForall (fmap (map sTyVarBind) mtvs), ppContext $ maybe [] sContext ctxt, pretty con]++instance Pretty (A.GadtDecl l) where+ pretty (A.GadtDecl _pos name ty) =+ myFsep [pretty name, text "::", pretty ty]++instance Pretty (A.ConDecl l) where+ pretty = pretty . sConDecl++instance Pretty (A.FieldDecl l) where+ pretty (A.FieldDecl _ names ty) =+ myFsepSimple $ (punctuate comma . map pretty $ names) +++ [text "::", pretty ty]+++instance Pretty (A.BangType l) where+ pretty = pretty . sBangType++instance Pretty (A.Deriving l) where+ pretty (A.Deriving _ []) = text "deriving" <+> parenList []+ pretty (A.Deriving _ [A.IHead _ d []]) = text "deriving" <+> pretty d+ pretty (A.Deriving _ ihs) = text "deriving" <+> parenList (map pretty ihs)++------------------------- Types -------------------------+instance Pretty (A.Type l) where+ pretty = pretty . sType++instance Pretty (A.TyVarBind l) where+ pretty = pretty . sTyVarBind++---------------------------- Kinds ----------------------------++instance Pretty (A.Kind l) where+ pretty = pretty . sKind++------------------- Functional Dependencies -------------------+instance Pretty (A.FunDep l) where+ pretty = pretty . sFunDep++------------------------- Expressions -------------------------+instance SrcInfo loc => Pretty (A.Rhs loc) where+ pretty = pretty . sRhs++instance SrcInfo loc => Pretty (A.GuardedRhs loc) where+ pretty = pretty . sGuardedRhs++instance Pretty (A.Literal l) where+ pretty = pretty . sLiteral++instance SrcInfo loc => Pretty (A.Exp loc) where+ pretty = pretty . sExp++instance SrcInfo loc => Pretty (A.XAttr loc) where+ pretty = pretty . sXAttr++instance Pretty (A.XName l) where+ pretty = pretty . sXName++--------------------- Template Haskell -------------------------++instance SrcInfo loc => Pretty (A.Bracket loc) where+ pretty = pretty . sBracket++instance SrcInfo loc => Pretty (A.Splice loc) where+ pretty = pretty . sSplice++------------------------- Patterns -----------------------------++instance SrcInfo loc => Pretty (A.Pat loc) where+ pretty = pretty . sPat++instance SrcInfo loc => Pretty (A.PXAttr loc) where+ pretty = pretty . sPXAttr++instance SrcInfo loc => Pretty (A.PatField loc) where+ pretty = pretty . sPatField++--------------------- Regular Patterns -------------------------++instance SrcInfo loc => Pretty (A.RPat loc) where+ pretty = pretty . sRPat++instance Pretty (A.RPatOp l) where+ pretty = pretty . sRPatOp++------------------------- Case bodies -------------------------+instance SrcInfo loc => Pretty (A.Alt loc) where+ pretty = pretty . sAlt++instance SrcInfo loc => Pretty (A.GuardedAlts loc) where+ pretty = pretty . sGuardedAlts++instance SrcInfo loc => Pretty (A.GuardedAlt loc) where+ pretty = pretty . sGuardedAlt++------------------------- Statements in monads, guards & list comprehensions -----+instance SrcInfo loc => Pretty (A.Stmt loc) where+ pretty = pretty . sStmt++instance SrcInfo loc => Pretty (A.QualStmt loc) where+ pretty = pretty . sQualStmt++------------------------- Record updates+instance SrcInfo loc => Pretty (A.FieldUpdate loc) where+ pretty = pretty . sFieldUpdate++------------------------- Names -------------------------+instance Pretty (A.QOp l) where+ pretty = pretty . sQOp++instance Pretty (A.QName l) where+ pretty = pretty . sQName++instance Pretty (A.Op l) where+ pretty = pretty . sOp++instance Pretty (A.Name l) where+ pretty = pretty . sName++instance Pretty (A.IPName l) where+ pretty = pretty . sIPName++instance SrcInfo loc => Pretty (A.IPBind loc) where+ pretty = pretty . sIPBind++instance Pretty (A.CName l) where+ pretty = pretty . sCName++instance Pretty (A.Context l) where+ pretty (A.CxEmpty _) = mySep [text "()", text "=>"]+ pretty (A.CxSingle _ asst) = mySep [pretty asst, text "=>"]+ pretty (A.CxTuple _ assts) = myFsep $ [parenList (map pretty assts), text "=>"]+ pretty (A.CxParen _ asst) = parens (pretty asst)++-- hacked for multi-parameter type classes+instance Pretty (A.Asst l) where+ pretty = pretty . sAsst++------------------------- pp utils -------------------------+maybePP :: (a -> Doc) -> Maybe a -> Doc+maybePP pp Nothing = empty+maybePP pp (Just a) = pp a++parenList :: [Doc] -> Doc+parenList = parens . myFsepSimple . punctuate comma++hashParenList :: [Doc] -> Doc+hashParenList = hashParens . myFsepSimple . punctuate comma+ where hashParens = parens . hashes+ hashes = \doc -> char '#' <> doc <> char '#'++braceList :: [Doc] -> Doc+braceList = braces . myFsepSimple . punctuate comma++bracketList :: [Doc] -> Doc+bracketList = brackets . myFsepSimple++-- Wrap in braces and semicolons, with an extra space at the start in+-- case the first doc begins with "-", which would be scanned as {-+flatBlock :: [Doc] -> Doc+flatBlock = braces . (space <>) . hsep . punctuate semi++-- Same, but put each thing on a separate line+prettyBlock :: [Doc] -> Doc+prettyBlock = braces . (space <>) . vcat . punctuate semi++-- Monadic PP Combinators -- these examine the env++blankline :: Doc -> Doc+blankline dl = do{e<-getPPEnv;if spacing e && layout e /= PPNoLayout+ then space $$ dl else dl}+topLevel :: Doc -> [Doc] -> Doc+topLevel header dl = do+ e <- fmap layout getPPEnv+ case e of+ PPOffsideRule -> header $$ vcat dl+ PPSemiColon -> header $$ prettyBlock dl+ PPInLine -> header $$ prettyBlock dl+ PPNoLayout -> header <+> flatBlock dl++ppBody :: (PPHsMode -> Int) -> [Doc] -> Doc+ppBody f dl = do+ e <- fmap layout getPPEnv+ case e of PPOffsideRule -> indent+ PPSemiColon -> indentExplicit+ _ -> flatBlock dl+ where+ indent = do{i <-fmap f getPPEnv;nest i . vcat $ dl}+ indentExplicit = do {i <- fmap f getPPEnv;+ nest i . prettyBlock $ dl}++($$$) :: Doc -> Doc -> Doc+a $$$ b = layoutChoice (a $$) (a <+>) b++mySep :: [Doc] -> Doc+mySep = layoutChoice mySep' hsep+ where+ -- ensure paragraph fills with indentation.+ mySep' [x] = x+ mySep' (x:xs) = x <+> fsep xs+ mySep' [] = error "Internal error: mySep"++myVcat :: [Doc] -> Doc+myVcat = layoutChoice vcat hsep++myFsepSimple :: [Doc] -> Doc+myFsepSimple = layoutChoice fsep hsep++-- same, except that continuation lines are indented,+-- which is necessary to avoid triggering the offside rule.+myFsep :: [Doc] -> Doc+myFsep = layoutChoice fsep' hsep+ where fsep' [] = empty+ fsep' (d:ds) = do+ e <- getPPEnv+ let n = onsideIndent e+ nest n (fsep (nest (-n) d:ds))++layoutChoice :: (a -> Doc) -> (a -> Doc) -> a -> Doc+layoutChoice a b dl = do e <- getPPEnv+ if layout e == PPOffsideRule ||+ layout e == PPSemiColon+ then a dl else b dl++-- Prefix something with a LINE pragma, if requested.+-- GHC's LINE pragma actually sets the current line number to n-1, so+-- that the following line is line n. But if there's no newline before+-- the line we're talking about, we need to compensate by adding 1.++markLine :: SrcInfo s => s -> Doc -> Doc+markLine loc doc = do+ e <- getPPEnv+ let y = startLine loc+ let line l =+ text ("{-# LINE " ++ show l ++ " \"" ++ fileName loc ++ "\" #-}")+ if linePragmas e then layoutChoice (line y $$) (line (y+1) <+>) doc+ else doc++--------------------------------------------------------------------------------+-- Pretty-printing of internal constructs, for error messages while parsing++instance SrcInfo loc => Pretty (P.PExp loc) where+ pretty (P.Lit _ l) = pretty l+ pretty (P.InfixApp _ a op b) = myFsep [pretty a, pretty op, pretty b]+ pretty (P.NegApp _ e) = myFsep [char '-', pretty e]+ pretty (P.App _ a b) = myFsep [pretty a, pretty b]+ pretty (P.Lambda _loc expList ppBody) = myFsep $+ char '\\' : map pretty expList ++ [text "->", pretty ppBody]+ pretty (P.Let _ (A.BDecls _ declList) letBody) =+ ppLetExp declList letBody+ pretty (P.Let _ (A.IPBinds _ bindList) letBody) =+ ppLetExp bindList letBody+ pretty (P.If _ cond thenexp elsexp) =+ myFsep [text "if", pretty cond,+ text "then", pretty thenexp,+ text "else", pretty elsexp]+ pretty (P.Case _ cond altList) =+ myFsep [text "case", pretty cond, text "of"]+ $$$ ppBody caseIndent (map pretty altList)+ pretty (P.Do _ stmtList) =+ text "do" $$$ ppBody doIndent (map pretty stmtList)+ pretty (P.MDo _ stmtList) =+ text "mdo" $$$ ppBody doIndent (map pretty stmtList)+ pretty (P.Var _ name) = pretty name+ pretty (P.IPVar _ ipname) = pretty ipname+ pretty (P.Con _ name) = pretty name+ pretty (P.TupleSection _ mExpList) = parenList . map (maybePP pretty) $ mExpList+-- pretty (P.FSContext _ e) = freesects . pretty $ e+ pretty (P.FSContext _ e) = myFsep $ [text "_[", pretty e, text "]_"]+ pretty (P.Paren _ e) = parens . pretty $ e+ pretty (P.RecConstr _ c fieldList) =+ pretty c <> (braceList . map pretty $ fieldList)+ pretty (P.RecUpdate _ e fieldList) =+ pretty e <> (braceList . map pretty $ fieldList)+ pretty (P.List _ list) =+ bracketList . punctuate comma . map pretty $ list+ pretty (P.EnumFrom _ e) =+ bracketList [pretty e, text ".."]+ pretty (P.EnumFromTo _ from to) =+ bracketList [pretty from, text "..", pretty to]+ pretty (P.EnumFromThen _ from thenE) =+ bracketList [pretty from <> comma, pretty thenE, text ".."]+ pretty (P.EnumFromThenTo _ from thenE to) =+ bracketList [pretty from <> comma, pretty thenE,+ text "..", pretty to]+ pretty (P.ParComp _ e qualLists) =+ bracketList (intersperse (char '|') $+ pretty e : (punctuate comma . concatMap (map pretty) $ qualLists))+ pretty (P.ExpTypeSig _pos e ty) =+ myFsep [pretty e, text "::", pretty ty]+ pretty (P.BracketExp _ b) = pretty b+ pretty (P.SpliceExp _ s) = pretty s+ pretty (P.TypQuote _ t) = text "\'\'" <> pretty t+ pretty (P.VarQuote _ x) = text "\'" <> pretty x+ pretty (P.QuasiQuote _ n qt) = text ("[$" ++ n ++ "|" ++ qt ++ "|]")+ pretty (P.XTag _ n attrs mattr cs) =+ let ax = maybe [] (return . pretty) mattr+ in hcat $+ (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [char '>']):+ map pretty cs ++ [myFsep $ [text "</" <> pretty n, char '>']]+ pretty (P.XETag _ n attrs mattr) =+ let ax = maybe [] (return . pretty) mattr+ in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"]+ pretty (P.XPcdata _ s) = text s+ pretty (P.XExpTag _ e) =+ myFsep $ [text "<%", pretty e, text "%>"]+ pretty (P.XChildTag _ es) =+ myFsep $ text "<%>" : map pretty es ++ [text "</%>"]+ pretty (P.CorePragma _ s e) = myFsep $ map text ["{-# CORE", show s, "#-}"] ++ [pretty e]+ pretty (P.SCCPragma _ s e) = myFsep $ map text ["{-# SCC", show s, "#-}"] ++ [pretty e]+ pretty (P.GenPragma _ s (a,b) (c,d) e) =+ myFsep $ [text "{-# GENERATED", text $ show s,+ int a, char ':', int b, char '-',+ int c, char ':', int d, text "#-}", pretty e]+ pretty (P.Proc _ p e) = myFsep $ [text "proc", pretty p, text "->", pretty e]+ pretty (P.LeftArrApp _ l r) = myFsep $ [pretty l, text "-<", pretty r]+ pretty (P.RightArrApp _ l r) = myFsep $ [pretty l, text ">-", pretty r]+ pretty (P.LeftArrHighApp _ l r) = myFsep $ [pretty l, text "-<<", pretty r]+ pretty (P.RightArrHighApp _ l r) = myFsep $ [pretty l, text ">>-", pretty r]+ pretty (P.AsPat _ name (P.IrrPat _ pat)) =+ myFsep [pretty name <> char '@', char '~' <> pretty pat]+ pretty (P.AsPat _ name pat) =+ hcat [pretty name, char '@', pretty pat]+ pretty (P.FreeSectSlot _) = text "__"+ pretty (P.WildCard _) = char '_'+ pretty (P.IrrPat _ pat) = char '~' <> pretty pat+ pretty (P.PostOp _ e op) = pretty e <+> pretty op+ pretty (P.PreOp _ op e) = pretty op <+> pretty e+ pretty (P.ViewPat _ e p) =+ myFsep [pretty e, text "->", pretty p]+ pretty (P.SeqRP _ rs) = myFsep $ text "(/" : map pretty rs ++ [text "/)"]+ pretty (P.GuardRP _ r gs) =+ myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"]+ pretty (P.EitherRP _ r1 r2) = parens . myFsep $ [pretty r1, char '|', pretty r2]+ pretty (P.CAsRP _ n (P.IrrPat _ e)) =+ myFsep [pretty n <> text "@:", char '~' <> pretty e]+ pretty (P.CAsRP _ n r) = hcat [pretty n, text "@:", pretty r]+ pretty (P.XRPats _ ps) =+ myFsep $ text "<[" : map pretty ps ++ [text "%>"]+ pretty (P.ExplTypeArg _ qn t) =+ myFsep [pretty qn, text "{|", pretty t, text "|}"]+ pretty (P.BangPat _ e) = text "!" <> pretty e++instance SrcInfo loc => Pretty (P.PFieldUpdate loc) where+ pretty (P.FieldUpdate _ name e) =+ myFsep [pretty name, equals, pretty e]+ pretty (P.FieldPun _ name) = pretty name+ pretty (P.FieldWildcard _) = text ".."++instance SrcInfo loc => Pretty (P.ParseXAttr loc) where+ pretty (P.XAttr _ n v) =+ myFsep [pretty n, char '=', pretty v]++instance SrcInfo loc => Pretty (P.PContext loc) where+ pretty (P.CxEmpty _) = mySep [text "()", text "=>"]+ pretty (P.CxSingle _ asst) = mySep [pretty asst, text "=>"]+ pretty (P.CxTuple _ assts) = myFsep $ [parenList (map pretty assts), text "=>"]+ pretty (P.CxParen _ asst) = parens (pretty asst)++instance SrcInfo loc => Pretty (P.PAsst loc) where+ pretty (P.ClassA _ a ts) = myFsep $ ppQName (sQName a) : map (prettyPrec prec_atype) ts+ pretty (P.InfixA _ a op b) = myFsep $ [pretty a, ppQNameInfix (sQName op), pretty b]+ pretty (P.IParam _ i t) = myFsep $ [pretty i, text "::", pretty t]+ pretty (P.EqualP _ t1 t2) = myFsep $ [pretty t1, text "~", pretty t2]++instance SrcInfo loc => Pretty (P.PType loc) where+ prettyPrec p (P.TyForall _ mtvs ctxt htype) = parensIf (p > 0) $+ myFsep [ppForall (fmap (map sTyVarBind) mtvs), maybePP pretty ctxt, pretty htype]+ prettyPrec p (P.TyFun _ a b) = parensIf (p > 0) $+ myFsep [prettyPrec prec_btype a, text "->", pretty b]+ prettyPrec _ (P.TyTuple _ bxd l) =+ let ds = map pretty l+ in case bxd of+ Boxed -> parenList ds+ Unboxed -> hashParenList ds+ prettyPrec _ (P.TyList _ t) = brackets $ pretty t+ prettyPrec p (P.TyApp _ a b) =+ {-+ | a == list_tycon = brackets $ pretty b -- special case+ | otherwise = -} parensIf (p > prec_btype) $+ myFsep [pretty a, prettyPrec prec_atype b]+ prettyPrec _ (P.TyVar _ name) = pretty name+ prettyPrec _ (P.TyCon _ name) = pretty name+ prettyPrec _ (P.TyParen _ t) = parens (pretty t)+ prettyPrec _ (P.TyPred _ asst) = pretty asst+ prettyPrec _ (P.TyInfix _ a op b) = myFsep [pretty a, ppQNameInfix (sQName op), pretty b]+ prettyPrec _ (P.TyKind _ t k) = parens (myFsep [pretty t, text "::", pretty k])
+ HSE/SrcLoc.hs view
@@ -0,0 +1,173 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.SrcLoc +-- Copyright : (c) Niklas Broberg 2009 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@chalmers.se +-- Stability : stable +-- Portability : portable +-- +-- This module defines various data types representing source location +-- information, of varying degree of preciseness. +-- +----------------------------------------------------------------------------- +module HSE.SrcLoc where + +#ifdef __GLASGOW_HASKELL__ +#ifdef BASE4 +import Data.Data +#else +import Data.Generics (Data(..),Typeable(..)) +#endif +#endif + +-- | A single position in the source. +data SrcLoc = SrcLoc + { srcFilename :: String + , srcLine :: Int + , srcColumn :: Int + } +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + + +-- | A portion of the source, spanning one or more lines and zero or more columns. +data SrcSpan = SrcSpan + { srcSpanFilename :: String + , srcSpanStartLine :: Int + , srcSpanStartColumn :: Int + , srcSpanEndLine :: Int + , srcSpanEndColumn :: Int + } +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + + +-- | Returns 'srcSpanStartLine' and 'srcSpanStartColumn' in a pair. +srcSpanStart :: SrcSpan -> (Int,Int) +srcSpanStart x = (srcSpanStartLine x, srcSpanStartColumn x) + +-- | Returns 'srcSpanEndLine' and 'srcSpanEndColumn' in a pair. +srcSpanEnd :: SrcSpan -> (Int,Int) +srcSpanEnd x = (srcSpanEndLine x, srcSpanEndColumn x) + + +-- | Combine two locations in the source to denote a span. +mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan +mkSrcSpan (SrcLoc fn sl sc) (SrcLoc _ el ec) = SrcSpan fn sl sc el ec + +-- | Merge two source spans into a single span from the start of the first +-- to the end of the second. Assumes that the two spans relate to the +-- same source file. +mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan +mergeSrcSpan (SrcSpan fn sl1 sc1 el1 ec1) (SrcSpan _ sl2 sc2 el2 ec2) = + let (sl,sc) = min (sl1,sc1) (sl2,sc2) + (el,ec) = max (el1,ec1) (el2,ec2) + in SrcSpan fn sl sc el ec + +-- | Test if a given span starts and ends at the same location. +isNullSpan :: SrcSpan -> Bool +isNullSpan ss = srcSpanStartLine ss == srcSpanEndLine ss && + srcSpanStartColumn ss >= srcSpanEndColumn ss + +-- | An entity located in the source. +data Loc a = Loc + { loc :: SrcSpan + , unLoc :: a + } + deriving (Eq,Ord,Show) + + +-- | A portion of the source, extended with information on the position of entities within the span. +data SrcSpanInfo = SrcSpanInfo + { srcInfoSpan :: SrcSpan +-- , explLayout :: Bool + , srcInfoPoints :: [SrcSpan] -- Marks the location of specific entities inside the span + } +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + +-- | Generate a 'SrcSpanInfo' with no positional information for entities. +noInfoSpan :: SrcSpan -> SrcSpanInfo +noInfoSpan ss = SrcSpanInfo ss [] + +-- | Generate a 'SrcSpanInfo' with the supplied positional information for entities. +infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo +infoSpan = SrcSpanInfo + +-- | Combine two 'SrcSpanInfo's into one that spans the combined source area of +-- the two arguments, leaving positional information blank. +combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo +combSpanInfo s1 s2 = SrcSpanInfo + (mergeSrcSpan (srcInfoSpan s1) (srcInfoSpan s2)) + [] + +-- | Short name for 'combSpanInfo' +(<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo +(<++>) = combSpanInfo + +-- | Optionally combine the first argument with the second, +-- or return it unchanged if the second argument is 'Nothing'. +(<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo +a <+?> b = case b of {Nothing -> a; Just b -> a <++> b} + +-- | Optionally combine the second argument with the first, +-- or return it unchanged if the first argument is 'Nothing'. +(<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo +a <?+> b = case a of {Nothing -> b; Just a -> a <++> b} + +-- | Add more positional information for entities of a span. +(<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo +ss@(SrcSpanInfo {srcInfoPoints = ps}) <** xs = ss {srcInfoPoints = ps ++ xs} + +-- | Merge two 'SrcSpan's and lift them to a 'SrcInfoSpan' with +-- no positional information for entities. +(<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo +a <^^> b = noInfoSpan (mergeSrcSpan a b) + +infixl 6 <^^> +infixl 5 <++> +infixl 4 <**, <+?>, <?+> + +-- | A class to work over all kinds of source location information. +class SrcInfo si where + toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> si + fromSrcInfo :: SrcSpanInfo -> si + getPointLoc :: si -> SrcLoc + fileName :: si -> String + startLine :: si -> Int + startColumn :: si -> Int + + getPointLoc si = SrcLoc (fileName si) (startLine si) (startColumn si) + +instance SrcInfo SrcLoc where + toSrcInfo s _ _ = s + fromSrcInfo si = SrcLoc (fileName si) (startLine si) (startColumn si) + fileName = srcFilename + startLine = srcLine + startColumn = srcColumn + +instance SrcInfo SrcSpan where + toSrcInfo st _ end = mkSrcSpan st end + fromSrcInfo = srcInfoSpan + fileName = srcSpanFilename + startLine = srcSpanStartLine + startColumn = srcSpanStartColumn + +instance SrcInfo SrcSpanInfo where + toSrcInfo st pts end = SrcSpanInfo (mkSrcSpan st end) pts + fromSrcInfo = id + fileName = fileName . srcInfoSpan + startLine = startLine . srcInfoSpan + startColumn = startColumn . srcInfoSpan
+ HSE/Syntax.hs view
@@ -0,0 +1,1002 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+-----------------------------------------------------------------------------+-- |+-- Module : Language.Haskell.Exts.Syntax+-- Copyright : (c) Niklas Broberg 2004-2009,+-- (c) The GHC Team, 1997-2000+-- License : BSD-style (see the file LICENSE.txt)+--+-- Maintainer : Niklas Broberg, d00nibro@chalmers.se+-- Stability : stable+-- Portability : portable+--+-- A suite of datatypes describing the abstract syntax of Haskell 98+-- <http://www.haskell.org/onlinereport/> plus registered extensions, including:+--+-- * multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)+--+-- * parameters of type class assertions are unrestricted (FlexibleContexts)+--+-- * 'forall' types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)+--+-- * pattern guards (PatternGuards)+--+-- * implicit parameters (ImplicitParameters)+--+-- * generalised algebraic data types (GADTs)+--+-- * template haskell (TemplateHaskell)+--+-- * empty data type declarations (EmptyDataDecls)+--+-- * unboxed tuples (UnboxedTuples)+--+-- * regular patterns (RegularPatterns)+--+-- * HSP-style XML expressions and patterns (XmlSyntax)+--+-----------------------------------------------------------------------------++module HSE.Syntax (+ -- * Modules+ Module(..), WarningText(..), ExportSpec(..),+ ImportDecl(..), ImportSpec(..), Assoc(..),+ -- * Declarations+ Decl(..), Binds(..), IPBind(..),+ -- ** Type classes and instances+ ClassDecl(..), InstDecl(..), Deriving,+ -- ** Data type declarations+ DataOrNew(..), ConDecl(..), QualConDecl(..), GadtDecl(..), BangType(..),+ -- ** Function bindings+ Match(..), Rhs(..), GuardedRhs(..),+ -- * Class Assertions and Contexts+ Context, FunDep(..), Asst(..),+ -- * Types+ Type(..), Boxed(..), Kind(..), TyVarBind(..),+ -- * Expressions+ Exp(..), Stmt(..), QualStmt(..), FieldUpdate(..),+ Alt(..), GuardedAlts(..), GuardedAlt(..), XAttr(..),+ -- * Patterns+ Pat(..), PatField(..), PXAttr(..), RPat(..), RPatOp(..),+ -- * Literals+ Literal(..),+ -- * Variables, Constructors and Operators+ ModuleName(..), QName(..), Name(..), QOp(..), Op(..),+ SpecialCon(..), CName(..), IPName(..), XName(..),++ -- * Template Haskell+ Bracket(..), Splice(..),++ -- * FFI+ Safety(..), CallConv(..),++ -- * Pragmas+ ModulePragma(..), Tool(..),+ Rule(..), RuleVar(..), Activation(..),+ Annotation(..),++ -- * Builtin names++ -- ** Modules+ prelude_mod, main_mod,+ -- ** Main function of a program+ main_name,+ -- ** Constructors+ unit_con_name, tuple_con_name, list_cons_name, unboxed_singleton_con_name,+ unit_con, tuple_con, unboxed_singleton_con,+ -- ** Special identifiers+ as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,+ export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name,+ -- ** Type constructors+ unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name, unboxed_singleton_tycon_name,+ unit_tycon, fun_tycon, list_tycon, tuple_tycon, unboxed_singleton_tycon,++ -- * Source coordinates+ SrcLoc(..),+ ) where+++#ifdef __GLASGOW_HASKELL__+#ifdef BASE4+import Data.Data+#else+import Data.Generics (Data(..),Typeable(..))+#endif+#endif++import HSE.SrcLoc (SrcLoc(..))++import HSE.Annotated.Syntax (Boxed(..), Tool(..))+++-- | The name of a Haskell module.+newtype ModuleName = ModuleName String+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Constructors with special syntax.+-- These names are never qualified, and always refer to builtin type or+-- data constructors.+data SpecialCon+ = UnitCon -- ^ unit type and data constructor @()@+ | ListCon -- ^ list type constructor @[]@+ | FunCon -- ^ function type constructor @->@+ | TupleCon Boxed Int -- ^ /n/-ary tuple type and data+ -- constructors @(,)@ etc, possibly boxed @(\#,\#)@+ | Cons -- ^ list data constructor @(:)@+ | UnboxedSingleCon -- ^ unboxed singleton tuple constructor @(\# \#)@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | This type is used to represent qualified variables, and also+-- qualified constructors.+data QName+ = Qual ModuleName Name -- ^ name qualified with a module name+ | UnQual Name -- ^ unqualified local name+ | Special SpecialCon -- ^ built-in constructor with special syntax+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | This type is used to represent variables, and also constructors.+data Name+ = Ident String -- ^ /varid/ or /conid/.+ | Symbol String -- ^ /varsym/ or /consym/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An implicit parameter name.+data IPName+ = IPDup String -- ^ ?/ident/, non-linear implicit parameter+ | IPLin String -- ^ %/ident/, linear implicit parameter+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Possibly qualified infix operators (/qop/), appearing in expressions.+data QOp+ = QVarOp QName -- ^ variable operator (/qvarop/)+ | QConOp QName -- ^ constructor operator (/qconop/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Operators appearing in @infix@ declarations are never qualified.+data Op+ = VarOp Name -- ^ variable operator (/varop/)+ | ConOp Name -- ^ constructor operator (/conop/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A name (/cname/) of a component of a class or data type in an @import@+-- or export specification.+data CName+ = VarName Name -- ^ name of a method or field+ | ConName Name -- ^ name of a data constructor+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A complete Haskell source module.+data Module = Module SrcLoc ModuleName [ModulePragma] (Maybe WarningText)+ (Maybe [ExportSpec]) [ImportDecl] [Decl]+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An item in a module's export specification.+data ExportSpec+ = EVar QName -- ^ variable+ | EAbs QName -- ^ @T@:+ -- a class or datatype exported abstractly,+ -- or a type synonym.+ | EThingAll QName -- ^ @T(..)@:+ -- a class exported with all of its methods, or+ -- a datatype exported with all of its constructors.+ | EThingWith QName [CName] -- ^ @T(C_1,...,C_n)@:+ -- a class exported with some of its methods, or+ -- a datatype exported with some of its constructors.+ | EModuleContents ModuleName -- ^ @module M@:+ -- re-export a module.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An import declaration.+data ImportDecl = ImportDecl+ { importLoc :: SrcLoc -- ^ position of the @import@ keyword.+ , importModule :: ModuleName -- ^ name of the module imported.+ , importQualified :: Bool -- ^ imported @qualified@?+ , importSrc :: Bool -- ^ imported with @{-\# SOURCE \#-}@?+ , importPkg :: Maybe String -- ^ imported with explicit package name+ , importAs :: Maybe ModuleName -- ^ optional alias name in an @as@ clause.+ , importSpecs :: Maybe (Bool,[ImportSpec])+ -- ^ optional list of import specifications.+ -- The 'Bool' is 'True' if the names are excluded+ -- by @hiding@.+ }+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An import specification, representing a single explicit item imported+-- (or hidden) from a module.+data ImportSpec+ = IVar Name -- ^ variable+ | IAbs Name -- ^ @T@:+ -- the name of a class, datatype or type synonym.+ | IThingAll Name -- ^ @T(..)@:+ -- a class imported with all of its methods, or+ -- a datatype imported with all of its constructors.+ | IThingWith Name [CName] -- ^ @T(C_1,...,C_n)@:+ -- a class imported with some of its methods, or+ -- a datatype imported with some of its constructors.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Associativity of an operator.+data Assoc+ = AssocNone -- ^ non-associative operator (declared with @infix@)+ | AssocLeft -- ^ left-associative operator (declared with @infixl@).+ | AssocRight -- ^ right-associative operator (declared with @infixr@)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A single derived instance, which may have arguments since it may be a MPTC.+type Deriving = (QName, [Type])++-- | A top-level declaration.+data Decl+ = TypeDecl SrcLoc Name [TyVarBind] Type+ -- ^ A type declaration+ | TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind)+ -- ^ A type family declaration+ | DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving]+ -- ^ A data OR newtype declaration+ | GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving]+ -- ^ A data OR newtype declaration, GADT style+ | DataFamDecl SrcLoc {-data-} Context Name [TyVarBind] (Maybe Kind)+ -- ^ A data family declaration+ | TypeInsDecl SrcLoc Type Type+ -- ^ A type family instance declaration+ | DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving]+ -- ^ A data family instance declaration+ | GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]+ -- ^ A data family instance declaration, GADT style+ | ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl]+ -- ^ A declaration of a type class+ | InstDecl SrcLoc Context QName [Type] [InstDecl]+ -- ^ An declaration of a type class instance+ | DerivDecl SrcLoc Context QName [Type]+ -- ^ A standalone deriving declaration+ | InfixDecl SrcLoc Assoc Int [Op]+ -- ^ A declaration of operator fixity+ | DefaultDecl SrcLoc [Type]+ -- ^ A declaration of default types+ | SpliceDecl SrcLoc Exp+ -- ^ A Template Haskell splicing declaration+ | TypeSig SrcLoc [Name] Type+ -- ^ A type signature declaration+ | FunBind [Match]+ -- ^ A set of function binding clauses+ | PatBind SrcLoc Pat (Maybe Type) Rhs {-where-} Binds+ -- ^ A pattern binding+ | ForImp SrcLoc CallConv Safety String Name Type+ -- ^ A foreign import declaration+ | ForExp SrcLoc CallConv String Name Type+ -- ^ A foreign export declaration++ | RulePragmaDecl SrcLoc [Rule]+ -- ^ A RULES pragma+ | DeprPragmaDecl SrcLoc [([Name], String)]+ -- ^ A DEPRECATED pragma+ | WarnPragmaDecl SrcLoc [([Name], String)]+ -- ^ A WARNING pragma+ | InlineSig SrcLoc Bool Activation QName+ -- ^ An INLINE pragma+ | InlineConlikeSig SrcLoc Activation QName+ -- ^ An INLINE CONLIKE pragma+ | SpecSig SrcLoc QName [Type]+ -- ^ A SPECIALISE pragma+ | SpecInlineSig SrcLoc Bool Activation QName [Type]+ -- ^ A SPECIALISE INLINE pragma+ | InstSig SrcLoc Context QName [Type]+ -- ^ A SPECIALISE instance pragma+ | AnnPragma SrcLoc Annotation+ -- ^ An ANN pragma+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An annotation through an ANN pragma.+data Annotation+ = Ann Name Exp+ -- ^ An annotation for a declared name.+ | TypeAnn Name Exp+ -- ^ An annotation for a declared type.+ | ModuleAnn Exp+ -- ^ An annotation for the defining module.+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A flag stating whether a declaration is a data or newtype declaration.+data DataOrNew = DataType | NewType+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A binding group inside a @let@ or @where@ clause.+data Binds+ = BDecls [Decl] -- ^ An ordinary binding group+ | IPBinds [IPBind] -- ^ A binding group for implicit parameters+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A binding of an implicit parameter.+data IPBind = IPBind SrcLoc IPName Exp+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Clauses of a function binding.+data Match+ = Match SrcLoc Name [Pat] (Maybe Type) Rhs {-where-} Binds+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A single constructor declaration within a data type declaration,+-- which may have an existential quantification binding.+data QualConDecl+ = QualConDecl SrcLoc+ {-forall-} [TyVarBind] {- . -} Context+ {- => -} ConDecl+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declaration of an ordinary data constructor.+data ConDecl+ = ConDecl Name [BangType]+ -- ^ ordinary data constructor+ | InfixConDecl BangType Name BangType+ -- ^ infix data constructor+ | RecDecl Name [([Name],BangType)]+ -- ^ record constructor+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A single constructor declaration in a GADT data type declaration.+data GadtDecl+ = GadtDecl SrcLoc Name Type+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declarations inside a class declaration.+data ClassDecl+ = ClsDecl Decl+ -- ^ ordinary declaration+ | ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind)+ -- ^ declaration of an associated data type+ | ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind)+ -- ^ declaration of an associated type synonym+ | ClsTyDef SrcLoc Type Type+ -- ^ default choice for an associated type synonym+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Declarations inside an instance declaration.+data InstDecl+ = InsDecl Decl+ -- ^ ordinary declaration+ | InsType SrcLoc Type Type+ -- ^ an associated type definition+ | InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving]+ -- ^ an associated data type implementation+ | InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]+ -- ^ an associated data type implemented using GADT style+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The type of a constructor argument or field, optionally including+-- a strictness annotation.+data BangType+ = BangedTy Type -- ^ strict component, marked with \"@!@\"+ | UnBangedTy Type -- ^ non-strict component+ | UnpackedTy Type -- ^ unboxed component, marked with an UNPACK pragma+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The right hand side of a function or pattern binding.+data Rhs+ = UnGuardedRhs Exp -- ^ unguarded right hand side (/exp/)+ | GuardedRhss [GuardedRhs]+ -- ^ guarded right hand side (/gdrhs/)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A guarded right hand side @|@ /stmts/ @=@ /exp/.+-- The guard is a series of statements when using pattern guards,+-- otherwise it will be a single qualifier expression.+data GuardedRhs+ = GuardedRhs SrcLoc [Stmt] Exp+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A type qualified with a context.+-- An unqualified type has an empty context.+data Type+ = TyForall+ (Maybe [TyVarBind])+ Context+ Type -- ^ qualified type+ | TyFun Type Type -- ^ function type+ | TyTuple Boxed [Type] -- ^ tuple type, possibly boxed+ | TyList Type -- ^ list syntax, e.g. [a], as opposed to [] a+ | TyApp Type Type -- ^ application of a type constructor+ | TyVar Name -- ^ type variable+ | TyCon QName -- ^ named type or type constructor+ | TyParen Type -- ^ type surrounded by parentheses+ | TyInfix Type QName Type -- ^ infix type constructor+ | TyKind Type Kind -- ^ type with explicit kind signature+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A type variable declaration, optionally with an explicit kind annotation.+data TyVarBind+ = KindedVar Name Kind -- ^ variable binding with kind annotation+ | UnkindedVar Name -- ^ ordinary variable binding+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An explicit kind annotation.+data Kind+ = KindStar -- ^ @*@, the kind of types+ | KindBang -- ^ @!@, the kind of unboxed types+ | KindFn Kind Kind -- ^ @->@, the kind of a type constructor+ | KindParen Kind -- ^ a kind surrounded by parentheses+ | KindVar Name -- ^ a kind variable (as of yet unsupported by compilers)+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A functional dependency, given on the form+-- l1 l2 ... ln -> r2 r3 .. rn+data FunDep+ = FunDep [Name] [Name]+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A context is a set of assertions+type Context = [Asst]++-- | Class assertions.+-- In Haskell 98, the argument would be a /tyvar/, but this definition+-- allows multiple parameters, and allows them to be /type/s.+-- Also extended with support for implicit parameters and equality constraints.+data Asst = ClassA QName [Type] -- ^ ordinary class assertion+ | InfixA Type QName Type -- ^ class assertion where the class name is given infix+ | IParam IPName Type -- ^ implicit parameter assertion+ | EqualP Type Type -- ^ type equality constraint+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | /literal/+-- Values of this type hold the abstract value of the literal, not the+-- precise string representation used. For example, @10@, @0o12@ and @0xa@+-- have the same representation.+data Literal+ = Char Char -- ^ character literal+ | String String -- ^ string literal+ | Int Integer -- ^ integer literal+ | Frac Rational -- ^ floating point literal+ | PrimInt Integer -- ^ unboxed integer literal+ | PrimWord Integer -- ^ unboxed word literal+ | PrimFloat Rational -- ^ unboxed float literal+ | PrimDouble Rational -- ^ unboxed double literal+ | PrimChar Char -- ^ unboxed character literal+ | PrimString String -- ^ unboxed string literal+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Haskell expressions.+data Exp+ = Var QName -- ^ variable+ | FreeSectSlot -- ^ FreeSect placeholder: @__@+ | IPVar IPName -- ^ implicit parameter variable+ | Con QName -- ^ data constructor+ | Lit Literal -- ^ literal constant+ | InfixApp Exp QOp Exp -- ^ infix application+ | App Exp Exp -- ^ ordinary application+ | NegApp Exp -- ^ negation expression @-/exp/@ (unary minus)+ | Lambda SrcLoc [Pat] Exp -- ^ lambda expression+ | Let Binds Exp -- ^ local declarations with @let@ ... @in@ ...+ | If Exp Exp Exp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/+ | Case Exp [Alt] -- ^ @case@ /exp/ @of@ /alts/+ | Do [Stmt] -- ^ @do@-expression:+ -- the last statement in the list+ -- should be an expression.+ | MDo [Stmt] -- ^ @mdo@-expression+ | Tuple [Exp] -- ^ tuple expression+ | TupleSection [Maybe Exp] -- ^ tuple section expression, e.g. @(,,3)@+ | List [Exp] -- ^ list expression+ | FSContext Exp -- ^ FreeSect context+ | Paren Exp -- ^ parenthesised expression+ | LeftSection Exp QOp -- ^ left section @(@/exp/ /qop/@)@+ | RightSection QOp Exp -- ^ right section @(@/qop/ /exp/@)@+ | RecConstr QName [FieldUpdate]+ -- ^ record construction expression+ | RecUpdate Exp [FieldUpdate]+ -- ^ record update expression+ | EnumFrom Exp -- ^ unbounded arithmetic sequence,+ -- incrementing by 1: @[from ..]@+ | EnumFromTo Exp Exp -- ^ bounded arithmetic sequence,+ -- incrementing by 1 @[from .. to]@+ | EnumFromThen Exp Exp -- ^ unbounded arithmetic sequence,+ -- with first two elements given @[from, then ..]@+ | EnumFromThenTo Exp Exp Exp+ -- ^ bounded arithmetic sequence,+ -- with first two elements given @[from, then .. to]@+ | ListComp Exp [QualStmt] -- ^ ordinary list comprehension+ | ParComp Exp [[QualStmt]] -- ^ parallel list comprehension+ | ExpTypeSig SrcLoc Exp Type -- ^ expression with explicit type signature++ | VarQuote QName -- ^ @'x@ for template haskell reifying of expressions+ | TypQuote QName -- ^ @''T@ for template haskell reifying of types+ | BracketExp Bracket -- ^ template haskell bracket expression+ | SpliceExp Splice -- ^ template haskell splice expression+ | QuasiQuote String String -- ^ quasi-quotaion: @[$/name/| /string/ |]@++-- Hsx+ | XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp]+ -- ^ xml element, with attributes and children+ | XETag SrcLoc XName [XAttr] (Maybe Exp)+ -- ^ empty xml element, with attributes+ | XPcdata String -- ^ PCDATA child element+ | XExpTag Exp -- ^ escaped haskell expression inside xml+ | XChildTag SrcLoc [Exp] -- ^ children of an xml element++-- Pragmas+ | CorePragma String Exp -- ^ CORE pragma+ | SCCPragma String Exp -- ^ SCC pragma+ | GenPragma String (Int, Int) (Int, Int) Exp+ -- ^ GENERATED pragma++-- Arrows+ | Proc SrcLoc Pat Exp -- ^ arrows proc: @proc@ /pat/ @->@ /exp/+ | LeftArrApp Exp Exp -- ^ arrow application (from left): /exp/ @-<@ /exp/+ | RightArrApp Exp Exp -- ^ arrow application (from right): /exp/ @>-@ /exp/+ | LeftArrHighApp Exp Exp -- ^ higher-order arrow application (from left): /exp/ @-<<@ /exp/+ | RightArrHighApp Exp Exp -- ^ higher-order arrow application (from right): /exp/ @>>-@ /exp/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The name of an xml element or attribute,+-- possibly qualified with a namespace.+data XName+ = XName String -- <name ...+ | XDomName String String -- <dom:name ...+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An xml attribute, which is a name-expression pair.+data XAttr = XAttr XName Exp+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A template haskell bracket expression.+data Bracket+ = ExpBracket Exp -- ^ expression bracket: @[| ... |]@+ | PatBracket Pat -- ^ pattern bracket: @[p| ... |]@+ | TypeBracket Type -- ^ type bracket: @[t| ... |]@+ | DeclBracket [Decl] -- ^ declaration bracket: @[d| ... |]@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A template haskell splice expression+data Splice+ = IdSplice String -- ^ variable splice: @$var@+ | ParenSplice Exp -- ^ parenthesised expression splice: @$(/exp/)@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The safety of a foreign function call.+data Safety+ = PlayRisky -- ^ unsafe+ | PlaySafe Bool -- ^ safe ('False') or threadsafe ('True')+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The calling convention of a foreign function call.+data CallConv+ = StdCall+ | CCall+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A top level options pragma, preceding the module header.+data ModulePragma+ = LanguagePragma SrcLoc [Name] -- ^ LANGUAGE pragma+ | OptionsPragma SrcLoc (Maybe Tool) String+ -- ^ OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC+ | AnnModulePragma SrcLoc Annotation+ -- ^ ANN pragma with module scope+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Activation clause of a RULES pragma.+data Activation+ = AlwaysActive+ | ActiveFrom Int+ | ActiveUntil Int+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The body of a RULES pragma.+data Rule+ = Rule String Activation (Maybe [RuleVar]) Exp Exp+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Variables used in a RULES pragma, optionally annotated with types+data RuleVar+ = RuleVar Name+ | TypedRuleVar Name Type+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | Warning text to optionally use in the module header of e.g.+-- a deprecated module.+data WarningText+ = DeprText String+ | WarnText String+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif+++-- | A pattern, to be matched against a value.+data Pat+ = PVar Name -- ^ variable+ | PLit Literal -- ^ literal constant+ | PNeg Pat -- ^ negated pattern+ | PNPlusK Name Integer -- ^ n+k pattern+ | PInfixApp Pat QName Pat -- ^ pattern with an infix data constructor+ | PApp QName [Pat] -- ^ data constructor and argument patterns+ | PTuple [Pat] -- ^ tuple pattern+ | PList [Pat] -- ^ list pattern+ | PParen Pat -- ^ parenthesized pattern+ | PRec QName [PatField] -- ^ labelled pattern, record style+ | PAsPat Name Pat -- ^ @\@@-pattern+ | PWildCard -- ^ wildcard pattern: @_@+ | PIrrPat Pat -- ^ irrefutable pattern: @~/pat/@+ | PatTypeSig SrcLoc Pat Type -- ^ pattern with type signature+ | PViewPat Exp Pat -- ^ view patterns of the form @(/exp/ -> /pat/)@+ | PRPat [RPat] -- ^ regular list pattern+ | PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat]+ -- ^ XML element pattern+ | PXETag SrcLoc XName [PXAttr] (Maybe Pat)+ -- ^ XML singleton element pattern+ | PXPcdata String -- ^ XML PCDATA pattern+ | PXPatTag Pat -- ^ XML embedded pattern+ | PXRPats [RPat] -- ^ XML regular list pattern+ | PExplTypeArg QName Type -- ^ Explicit generics style type argument e.g. @f {| Int |} x = ...@+ | PQuasiQuote String String -- ^ quasi quote patter: @[$/name/| /string/ |]@+ | PBangPat Pat -- ^ strict (bang) pattern: @f !x = ...@+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An XML attribute in a pattern.+data PXAttr = PXAttr XName Pat+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A regular pattern operator.+data RPatOp+ = RPStar -- ^ @*@ = 0 or more+ | RPStarG -- ^ @*!@ = 0 or more, greedy+ | RPPlus -- ^ @+@ = 1 or more+ | RPPlusG -- ^ @+!@ = 1 or more, greedy+ | RPOpt -- ^ @?@ = 0 or 1+ | RPOptG -- ^ @?!@ = 0 or 1, greedy+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An entity in a regular pattern.+data RPat+ = RPOp RPat RPatOp -- ^ operator pattern, e.g. pat*+ | RPEither RPat RPat -- ^ choice pattern, e.g. (1 | 2)+ | RPSeq [RPat] -- ^ sequence pattern, e.g. (| 1, 2, 3 |)+ | RPGuard Pat [Stmt] -- ^ guarded pattern, e.g. (| p | p < 3 |)+ | RPCAs Name RPat -- ^ non-linear variable binding, e.g. (foo\@:(1 | 2))*+ | RPAs Name RPat -- ^ linear variable binding, e.g. foo\@(1 | 2)+ | RPParen RPat -- ^ parenthesised pattern, e.g. (2*)+ | RPPat Pat -- ^ an ordinary pattern+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /fpat/ in a labeled record pattern.+data PatField+ = PFieldPat QName Pat -- ^ ordinary label-pattern pair+ | PFieldPun Name -- ^ record field pun+ | PFieldWildcard -- ^ record field wildcard+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A statement, representing both a /stmt/ in a @do@-expression,+-- an ordinary /qual/ in a list comprehension, as well as a /stmt/+-- in a pattern guard.+data Stmt+ = Generator SrcLoc Pat Exp+ -- ^ a generator: /pat/ @<-@ /exp/+ | Qualifier Exp -- ^ an /exp/ by itself: in a @do@-expression,+ -- an action whose result is discarded;+ -- in a list comprehension and pattern guard,+ -- a guard expression+ | LetStmt Binds -- ^ local bindings+ | RecStmt [Stmt] -- ^ a recursive binding group for arrows+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A general /transqual/ in a list comprehension,+-- which could potentially be a transform of the kind+-- enabled by TransformListComp.+data QualStmt+ = QualStmt Stmt -- ^ an ordinary statement+ | ThenTrans Exp -- ^ @then@ /exp/+ | ThenBy Exp Exp -- ^ @then@ /exp/ @by@ /exp/+ | GroupBy Exp -- ^ @then@ @group@ @by@ /exp/+ | GroupUsing Exp -- ^ @then@ @group@ @using@ /exp/+ | GroupByUsing Exp Exp -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /fbind/ in a labeled construction or update expression.+data FieldUpdate+ = FieldUpdate QName Exp -- ^ ordinary label-expresion pair+ | FieldPun Name -- ^ record field pun+ | FieldWildcard -- ^ record field wildcard+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | An /alt/ alternative in a @case@ expression.+data Alt+ = Alt SrcLoc Pat GuardedAlts Binds+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | The right-hand sides of a @case@ alternative,+-- which may be a single right-hand side or a+-- set of guarded ones.+data GuardedAlts+ = UnGuardedAlt Exp -- ^ @->@ /exp/+ | GuardedAlts [GuardedAlt] -- ^ /gdpat/+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-- | A guarded case alternative @|@ /stmts/ @->@ /exp/.+data GuardedAlt+ = GuardedAlt SrcLoc [Stmt] Exp+#ifdef __GLASGOW_HASKELL__+ deriving (Eq,Ord,Show,Typeable,Data)+#else+ deriving (Eq,Ord,Show)+#endif++-----------------------------------------------------------------------------+-- Builtin names.++prelude_mod, main_mod :: ModuleName+prelude_mod = ModuleName "Prelude"+main_mod = ModuleName "Main"++main_name :: Name+main_name = Ident "main"++unit_con_name :: QName+unit_con_name = Special UnitCon++tuple_con_name :: Boxed -> Int -> QName+tuple_con_name b i = Special (TupleCon b (i+1))++list_cons_name :: QName+list_cons_name = Special Cons++unboxed_singleton_con_name :: QName+unboxed_singleton_con_name = Special UnboxedSingleCon++unit_con :: Exp+unit_con = Con unit_con_name++tuple_con :: Boxed -> Int -> Exp+tuple_con b i = Con (tuple_con_name b i)++unboxed_singleton_con :: Exp+unboxed_singleton_con = Con (unboxed_singleton_con_name)++as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: Name+as_name = Ident "as"+qualified_name = Ident "qualified"+hiding_name = Ident "hiding"+minus_name = Symbol "-"+bang_name = Symbol "!"+dot_name = Symbol "."+star_name = Symbol "*"++export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name :: Name+export_name = Ident "export"+safe_name = Ident "safe"+unsafe_name = Ident "unsafe"+threadsafe_name = Ident "threadsafe"+stdcall_name = Ident "stdcall"+ccall_name = Ident "ccall"++unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: QName+unit_tycon_name = unit_con_name+fun_tycon_name = Special FunCon+list_tycon_name = Special ListCon+unboxed_singleton_tycon_name = Special UnboxedSingleCon++tuple_tycon_name :: Boxed -> Int -> QName+tuple_tycon_name b i = tuple_con_name b i++unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: Type+unit_tycon = TyCon unit_tycon_name+fun_tycon = TyCon fun_tycon_name+list_tycon = TyCon list_tycon_name+unboxed_singleton_tycon = TyCon unboxed_singleton_tycon_name++tuple_tycon :: Boxed -> Int -> Type+tuple_tycon b i = TyCon (tuple_tycon_name b i)
+ LICENSE view
@@ -0,0 +1,30 @@+Copyright (c) 2012, Andrew Seniuk+All rights reserved.++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 the name of Andrew Seniuk nor the names of other+ contributors may be used to endorse or promote products derived+ from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 COPYRIGHT+OWNER OR 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.
+ Main.hs view
@@ -0,0 +1,511 @@++-- Package: freesect-0.0.5+-- Executable: freesect+-- Author: Andrew Seniuk <rasfar@gmail.com>+-- Date: March 11, 2012+-- License: BSD3 (./LICENCE)+-- Synopsis: Extend Haskell to support free sections+-- Example: zipWith (f __ b __ d) as bs+-- Usage: See accompanying files 000-readme and z++{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-} -- needed for some of the type sigs.+{-# LANGUAGE CPP #-}+{- # LANGUAGE MultiParamTypeClasses #-}+{- # LANGUAGE RankNTypes #-} -- needed for the path accumulators.+{- # LANGUAGE ExistentialQuantification #-}+{- # LANGUAGE GADTs #-}+{- # LANGUAGE ScopedTypeVariables #-} -- needed for a pattern type sig.++-- CPP definitions are now set using compiler options; see ./z and ./ile.+-- #define ANNOTATED 0+-- #define PARALLEL 0+-- #define GHC_F 1++-- Most helpful sources:+-- - http://hpaste.org/steps/10722 -- use of everywhereM with State+-- - #haskell (thanks dreixel, quintessence, eyebloom, ...)++ module Main(main) where++ import System+ import IO++#if PARALLEL+ import Control.Parallel.Strategies+--import Control.Parallel -- Not imported with Strategies, but+ -- contains only par and pseq.+--import Control.Concurrent+---import Control.Exception+---import System.IO.Unsafe+---import Foreign+#endif++ import Data.Generics+ import Control.Monad.State++ import Random(StdGen,mkStdGen,next)+ import Data.List(isPrefixOf)++#if ANNOTATED+ import HSE.Annotated+ import HSE.SrcLoc+#else+ import HSE+#endif++ import HSE.Extension++ import FilesAndParsing++--------------------------------------------------------------------------------++#if ANNOTATED+ fs_module :: Module SrcSpanInfo -> Module SrcSpanInfo+#else+ fs_module :: Module -> Module+#endif+ fs_module m = m''+ where+ m' = everywhere (mkT step) m+ m'' = everywhere (mkT step2) m'+#if ANNOTATED+ step :: Rhs SrcSpanInfo -> Rhs SrcSpanInfo -- seems nec.+#else+-- step :: Rhs -> Rhs -- unnec.+#endif+#if ANNOTATED+ step (UnGuardedRhs srcSpanInfo e) = UnGuardedRhs srcSpanInfo e'+#else+ step (UnGuardedRhs e) = UnGuardedRhs e'+#endif+ where e' = fs_rhs_exp fresh e+ step x = x+#if ANNOTATED+ step2 :: Rhs SrcSpanInfo -> Rhs SrcSpanInfo -- seems nec.+#else+-- step2 :: Rhs -> Rhs -- unnec.+#endif+#if ANNOTATED+ step2 x@(UnGuardedRhs srcSpanInfo e)+ | still_fsss = UnGuardedRhs srcSpanInfo e'+#else+ step2 x@(UnGuardedRhs e)+ | still_fsss = UnGuardedRhs e''+#endif+ | otherwise = x+ where+ still_fsss = 0 < ( ( gcount (False `mkQ` p) x ) :: Int )+#if ANNOTATED+ p :: Exp SrcSpanInfo -> Bool+ p x@(FreeSectSlot _) = True+#else+-- p :: Exp -> Bool+ p x@FreeSectSlot = True+#endif+ p _ = False+ e'' = fs_rhs_exp fresh e'+#if ANNOTATED+ e' = Paren srcSpanInfo e+#else+ e' = Paren e+#endif+ step2 x = x+ fresh = fs_fresh_name m++ -- v.0.0.5:+ fs_rhs_exp :: Data a => String -> a -> a+--fs_rhs_exp fresh rhs = rhs'+ fs_rhs_exp fresh rhs = rhs''+ where+ rhs' = everywhere (mkT step) rhs+ rhs'' | num_fss_remaining > 0 = everywhere (mkT step2) rhs'+ | otherwise = rhs'+#if ANNOTATED+ step x@(FSContext srcSpanInfo e) = fs_lambda ps' x'+#else+ step x@(FSContext e) = fs_lambda ps' x'+#endif+ where (x',(ps,_)) = fs_name_slots fresh x+ ps' = reverse ps+ step x = x+ num_fss_remaining = ( gcount (False `mkQ` p) rhs' ) :: Int+-- num_fss_remaining = ( error $ show $ ( gcount (False `mkQ` p) rhs' ) :: Int ) :: Int+#if ANNOTATED+ p :: Exp SrcSpanInfo -> Bool+ p x@(FreeSectSlot _) = True+#else+-- p :: Exp -> Bool+ p x@FreeSectSlot = True+#endif+ p _ = False+ -- Default context inference works as follows:+ -- The (semilattice) join of all unbracketed __'s in a RHS is found.+ -- Then, the innermost enclosing Paren or infix $ determines the context,+ -- or -- if neither exists -- the whole RHS is taken as context.+ --+ -- Would prefer to use everywhereBut or something, to stop+ -- searching farther, but ... would need an "everywhereButM" I think,+ -- since need to pass on the info that an amenable Paren+ -- has already been found.+#if ANNOTATED+ step2 :: Exp SrcSpanInfo -> Exp SrcSpanInfo+#else+-- step2 :: Exp -> Exp+#endif+#if ANNOTATED+ -- | Paren l (Exp l)+ step2 x@(Paren srcSpanInfo e)+ | num_fss_remaining == gcount (False `mkQ` p) e+ = x'_+ | otherwise+ = x+ where+ x_ = FSContext srcSpanInfo e+#else+ step2 x@(Paren e)+ | num_fss_remaining == gcount (False `mkQ` p) e+ = x'_+ | otherwise+ = x+ where+ x_ = FSContext e+#endif+ -- (We safely discarded the Paren from the AST since FSContext will+ -- give Paren grouping behaviour in addition to freesect contexting.)+ (x',(ps,_)) = fs_name_slots fresh x_+ ps' = reverse ps+ x'_ = fs_lambda ps' x'+#if ANNOTATED+ -- | InfixApp l (Exp l) (QOp l) (Exp l)+ step2 x@(InfixApp srcSpanInfo e1 qop e2)+ | not good_op+ = x+ | num_fss_x < num_fss_remaining+ = x+ | num_fss_e2 == 0+ = InfixApp srcSpanInfo e1'_ qop e2+ | num_fss_e1 == 0+ = InfixApp srcSpanInfo e1 qop e2'_+ | otherwise+ = x'_+ where+ e1_ = FSContext srcSpanInfo e1+ e2_ = FSContext srcSpanInfo e2+ x_ = FSContext srcSpanInfo x+ -- May want to broaden this category? remember, it's a trade off,+ -- if you use an op for a freesect context delimiter, it can't+ -- be used inside a freesect with defaulting context.+ -- To see why $ was chosen, check out the S23.hs test file.+ good_op = case qop of+ (QVarOp _ (UnQual _ (Symbol _ "$"))) -> True+ _ -> False+#else+ step2 x@(InfixApp e1 qop e2)+ | not good_op+ = x+ | num_fss_x < num_fss_remaining+ = x+ | num_fss_e2 == 0+ = InfixApp e1'_ qop e2+ | num_fss_e1 == 0+ = InfixApp e1 qop e2'_+ | otherwise+ = x'_+ where+ e1_ = FSContext e1+ e2_ = FSContext e2+ x_ = FSContext x+ good_op = case qop of+ (QVarOp (UnQual (Symbol "$"))) -> True+ _ -> False+#endif+ (e1',(ps1,_)) = fs_name_slots fresh e1_+ ps1' = reverse ps1+ (e2',(ps2,_)) = fs_name_slots fresh e2_+ ps2' = reverse ps2+ (x',(ps,_)) = fs_name_slots fresh x_+ ps' = reverse ps+ e1'_ = fs_lambda ps1' e1'+ e2'_ = fs_lambda ps2' e2'+ x'_ = fs_lambda ps' x'+ num_fss_e1 = ( gcount (False `mkQ` p) e1 ) :: Int+ num_fss_e2 = ( gcount (False `mkQ` p) e2 ) :: Int+ num_fss_x = gcount (False `mkQ` p) x+ step2 x = x++#if ANNOTATED+ fs_lambda :: [String] -> Exp SrcSpanInfo -> Exp SrcSpanInfo -- seems nec.+#else+--fs_lambda :: [String] -> Exp -> Exp -- unnec.+#endif+ fs_lambda ps_lambda e_lambda+#if ANNOTATED+ | null ps_lambda = error $ "Error: Free section contains no wildcards.\n"+ ++ showSLorSSI ssi+#else+ | null ps_lambda = error $ "Error: Free section contains no wildcards.\n"+ ++ "(Source location not available, try -annotated.)\n"+#endif+ | otherwise = lambda+ where+#if ANNOTATED+ lambda = Lambda ssi ps_lambda' e_lambda''+ ps_lambda' = map (\x->(PVar ssi (Ident ssi x))) ps_lambda+ e_lambda'@(FSContext ssi e) = e_lambda+ e_lambda'' = e+#else+ lambda = Lambda srcloc ps_lambda' e_lambda''+ ps_lambda' = map (\x->(PVar (Ident x))) ps_lambda+ e_lambda'@(FSContext e) = e_lambda+ e_lambda'' = e+ srcloc = SrcLoc "" 0 0+#endif++#if ANNOTATED+ showSLorSSI :: SrcSpanInfo -> String+ showSLorSSI (SrcSpanInfo si _)+ = fileName si ++ ": line=" ++ show (startLine si)+ ++ " col=" ++ show (startColumn si)+#else+ showSLorSSI :: SrcLoc -> String+ showSLorSSI sl@(SrcLoc n l c)+ = n ++ ": line=" ++ show l ++ " col=" ++ show c+#endif++--------------------------------------------------------------------------------++ -- Perhaps ironically, I don't like using partially-point-free function+ -- declarations like this, but I couldn't figure out what to do with+ -- the second parameter if I made it explicit!+ -- We need to construct the fresh names in this recursion anyway, so+ -- may as well collect them rather than recompute them in the caller,+ -- although we could because they are canonically constructable from+ -- fresh and n, the Int part of the state.+ fs_name_slots :: Data a => String -> a -> (a,([String],Int))+ fs_name_slots fresh+ = flip runState ([],0) . everywhereM (mkM step)+ where+#if ANNOTATED+ step :: MonadState ([String],Int) m => Exp SrcSpanInfo -> m (Exp SrcSpanInfo) -- seems nec.+#else+-- step :: MonadState ([String],Int) m => Exp -> m Exp -- unnec.+#endif+#if ANNOTATED+ step (FreeSectSlot srcSpanInfo)+#else+ step FreeSectSlot+#endif+ = do (ss,n) <- get+ let s = fresh ++ show n+-- let s = "freeSect_" ++ show n+ put ((s:ss),(1+n))+#if ANNOTATED+ return $ ( Var srcSpanInfo ( UnQual srcSpanInfo ( Ident srcSpanInfo s ) ) )+#else+ return $ Var $ UnQual $ Ident $ s+#endif+ step x = return x++ fs_all_identifiers :: Data a => a -> [String]+ fs_all_identifiers = everything (++) ([] `mkQ` f)+ where+#if ANNOTATED+ f :: (Name SrcSpanInfo) -> [String] -- seems nec.+#else+-- f :: Name -> [String] -- unnec.+#endif+#if ANNOTATED+ f (Ident _ x) = [x]+#else+ f (Ident x) = [x]+#endif+ f _ = []++ -- The names which FreeSect inserts will never conflict with each other.+ -- We only need to assure they don't conflict with any existing names.+ -- Actually, we need to make sure the name created here is not a prefix+ -- of any existing name, because we add _XY to freesect slot names.+#if ANNOTATED+ fs_fresh_name :: Module SrcSpanInfo -> String+#else+ fs_fresh_name :: Module -> String+#endif+ fs_fresh_name m = f g+ where+ ss = fs_all_identifiers m+ g = mkStdGen 123 -- arbitrary seed+ -- The following was much simpler when accept whole of r+ -- as the random part of the name -- however, that made for+ -- ugly long names, and so we try for the shortest possible+ -- first. (If you never inspect the intermediate code, you+ -- wouldn't care if the var names were ugly...)+ f :: StdGen -> String+ f g | b = s+ | otherwise = f g' -- unlikely+ where (r,g') = next g+ (b,s) = f' rs (0,length rs)+ rs = show r+ f' :: String -> (Int,Int) -> (Bool,String)+ f' s (n,ntop) | n > ntop = (False,"")+ | not fail = (True,s'')+ | otherwise = f' s (1+n,ntop)+ where s' = take n s+ s'' = "fs" ++ s' ++ "_"+ fail = or $ map (isPrefixOf s'') ss++--------------------------------------------------------------------------------++#if ANNOTATED+ stripFSPragma :: Module SrcSpanInfo -> Module SrcSpanInfo+#else+ stripFSPragma :: Module -> Module+#endif+#if ANNOTATED+ stripFSPragma (Module x1 x2 prags x4 x5)+ = Module x1 x2 prags' x4 x5+#else+ stripFSPragma (Module x1 x2 prags x4 x5 x6 x7)+ = Module x1 x2 prags' x4 x5 x6 x7+#endif+ where prags' = map f prags+ f (LanguagePragma sl_or_ssi ns)+ = LanguagePragma sl_or_ssi $ filter p ns+ f x = x+#if ANNOTATED+ p n@(Ident sl_or_ssi "FreeSections") = False+#else+ p n@(Ident "FreeSections") = False+#endif+ p _ = True++#if ANNOTATED+ stripEmptyPragmaList :: Module SrcSpanInfo -> Module SrcSpanInfo+#else+ stripEmptyPragmaList :: Module -> Module+#endif+#if ANNOTATED+ stripEmptyPragmaList (Module x1 x2 prags x4 x5)+ = Module x1 x2 prags' x4 x5+#else+ stripEmptyPragmaList (Module x1 x2 prags x4 x5 x6 x7)+ = Module x1 x2 prags' x4 x5 x6 x7+#endif+ where prags' = filter p prags+ p (LanguagePragma ssi []) = False+ p _ = True++#if ANNOTATED+ fixModuleName :: String -> Module SrcSpanInfo -> Module SrcSpanInfo+#else+ fixModuleName :: String -> Module -> Module+#endif+#if ANNOTATED+ fixModuleName name (Module x1 x2 x3 x4 x5)+ = Module x1 name' x3 x4 x5+#else+ fixModuleName name (Module x1 x2 x3 x4 x5 x6 x7)+ = Module x1 name' x3 x4 x5 x6 x7+#endif+ where+#if ANNOTATED+ (Just (ModuleHead ssi _ mwt mesl)) = x2+ name' = Just (ModuleHead ssi (ModuleName ssi name) mwt mesl)+#else+ (ModuleName _) = x2+ name' = ModuleName name+#endif+ p (LanguagePragma ssi []) = False+ p _ = True++--------------------------------------------------------------------------------++ main:: IO ()+ main+ = do (+ outfile :+ lexsrc_pathnames+ ) <- getArgs+ lexsrc_serials_ <- mapM readSourcesFromFileOrDir lexsrc_pathnames+ let+ (pnames,lexsrc_serials) = unzip $ concat $ reverse lexsrc_serials_+#if ANNOTATED+#if PARALLEL+ parsedsrc_maybes = (runEval $ parTraversable rpar $ doParsing pnames lexsrc_serials) :: [ParseResult (Module SrcSpanInfo)]+#else+ parsedsrc_maybes = (doParsing pnames lexsrc_serials) :: [ParseResult (Module SrcSpanInfo)]+#endif+#else+ parsedsrc_maybes = (doParsing pnames lexsrc_serials) :: [ParseResult Module]+#endif+ let+-- parsed_srcs = error $ ( ( concatMap prettyPrint $ ( ( testParses parsedsrc_maybes ) :: [Module] ) ) :: String )+#if ANNOTATED+ parsed_srcs = ( testParses parsedsrc_maybes ) :: [Module SrcSpanInfo]+#else+ parsed_srcs = ( testParses parsedsrc_maybes ) :: [Module]+#endif+{--+ let+ test = ( error $ show $ map fs_FSS_lineal_chains parsed_srcs ) :: String+ print test+--}+ let+#if ANNOTATED+#if PARALLEL+ transformed_srcs = ( runEval $ parTraversable rpar $ + map fs_module parsed_srcs+ ) :: [Module SrcSpanInfo]+#else+ transformed_srcs = ( map fs_module parsed_srcs+ ) :: [Module SrcSpanInfo]+#endif+#else+#if PARALLEL+ transformed_srcs = ( runEval $ parTraversable rpar $ + map fs_module parsed_srcs+ ) :: [Module]+#else+ transformed_srcs = ( map fs_module parsed_srcs+ ) :: [Module]+#endif+#endif+-- transformed_srcs = parsed_srcs++ let+ transformed_srcs' = map stripFSPragma transformed_srcs+ transformed_srcs'' = map stripEmptyPragmaList transformed_srcs'+#if GHC_F+#else+ transformed_srcs''' = map (fixModuleName outfile) transformed_srcs''+#endif++#if GHC_F+ debug parsed_srcs transformed_srcs''+ writeFile outfile $ -- with ghc -F+ concatMap prettyPrint transformed_srcs''+#else+ debug parsed_srcs transformed_srcs'''+ writeFile (outfile++".hs") $+ concatMap prettyPrint transformed_srcs'''+#endif++ hFlush stdout++#if ANNOTATED+ debug :: [Module SrcSpanInfo] -> [Module SrcSpanInfo] -> IO ()+#else+ debug :: [Module] -> [Module] -> IO ()+#endif+ debug ms ms'+ = do+#if 0+ putStrLn $ show ms+ putStrLn $ show ms'+#endif+#if 0+ putStrLn $ concatMap prettyPrint ms+ putStrLn $ concatMap prettyPrint ms'+#endif+ return ()+
+ Makefile view
@@ -0,0 +1,16 @@++./freesect: ./Main.hs ./FilesAndParsing.hs ./HSE.hs ./HSE/Annotated.hs ./HSE/Annotated/Build.hs ./HSE/Annotated/ExactPrint.hs ./HSE/Annotated/Fixity.hs ./HSE/Annotated/Simplify.hs ./HSE/Annotated/Syntax.hs ./HSE/Build.hs ./HSE/Comments.hs ./HSE/ExtScheme.hs ./HSE/Extension.hs ./HSE/Fixity.hs ./HSE/Lexer.hs ./HSE/ParseMonad.hs ./HSE/ParseSyntax.hs ./HSE/ParseUtils.hs ./HSE/Parser.hs ./HSE/Pretty.hs ./HSE/SrcLoc.hs ./HSE/Syntax.hs ./HSE/InternalParser.hs+ csh ile++# Needed because of use of CPP definitions across multiple source files.+# They are defined using -optP to GHC, so changes to those options in ./ile+# require recompilation of affected modules.+./Main.hs: ./z+ touch Main.hs+./FilesAndParsing.hs: ./z+ touch FilesAndParsing.hs++./HSE/InternalParser.hs: ./HSE/InternalParser.ly+ happy -agc -o HSE/InternalParser.hs HSE/InternalParser.ly+# happy -info=INFO.txt -agc -o HSE/InternalParser.hs HSE/InternalParser.ly+
+ S14.hs view
@@ -0,0 +1,20 @@++ {- # LANGUAGE FreeSections #-} -- with GHC's -F you cannot...++ module S14(main) where++ import Char(ord)+ import List(intersperse)++ data D = D Int String++ main = printList $ zipWith _[ f (__,b) $ D __ d ]_ as cs+ where+ f :: (Char,Float) -> D -> String+ f (a,b) (D x y) = d ++ ( show ( b * fromIntegral (ord a + x) ) )+ as = take 20 ['a','b'..]+ cs = take 20 [1,3..]+ b = 1.7+ d = "pleasant"+ printList = putStrLn . concat . intersperse "\n"+
+ S15.hs view
@@ -0,0 +1,13 @@++ {- # LANGUAGE FreeSections #-} -- with GHC's -F you cannot...++ module S15(main) where++--main = print $ let f = (+) in zipWith f [1,2,3] [4,5,6]+--main = print $ let f = ( (+) __ 2 ) in map f [1,2,3]+ main = print $ let f = (+) __ 2 in map f [1,2,3]+--main = print $ map f [1,2,3] where f = (+) __ 2+--main = print $ map ( (+) __ 2 ) [1,2,3]+--main = print $ map _[ (+) __ 2 ]_ [1,2,3]+--main = print $ map _[ (\x y -> x+y) __ 2 ]_ [1,2,3]+
+ S23.hs view
@@ -0,0 +1,18 @@++ {- # LANGUAGE FreeSections #-} -- with GHC's -F you cannot...++ module S23 where++ -- Tests of default context inferencing.+ --+ -- This module won't compile, but you can examine the preprocessed code.++ sectA = zipWith ( f __ y __ )+ sectB = zipWith _[ f __ y __ ]_+ sectC = zipWith $ f __ y __+ sectD = zipWith ( f __ ( g __ z ) ) xs+ sectE = zipWith ( f __ $ g __ z ) xs+ sectF = zipWith $ f __ $ g __ z xs+ sectG = zipWith $ f __ $ g __ z+ sectH = f __ $ g __ z+
+ Setup.hs view
@@ -0,0 +1,5 @@+import Distribution.Simple+import System(getArgs)+main = do (a:_) <- getArgs+ putStr $ if a == "build" then "\n ** Please see 000-readme in the distro tarball for building and usage. **\n\n" else ""+ defaultMain
+ cln view
@@ -0,0 +1,26 @@+#!/bin/csh++echo "Check script first, it uses rm..."+exit 1++# Temp dirs created by GHC:+rm -rf ghc* >&! /dev/null++# Test input's GHC-generated files:+rm -f S[0-9][0-9].{o,hi} S[0-9][0-9] >&! /dev/null++# FreeSect linked binary:+#rm -f freesect >&! /dev/null++# FreeSect generated object and interface files:+#rm -f Main.{o,hi} >&! /dev/null+#rm -f FilesAndParsing.{o,hi} >&! /dev/null++# Patched HSE generated object and interface files:+#rm -f HSE.{o,hi} >&! /dev/null+#rm -f HSE/*.{o,hi} >&! /dev/null+#rm -f HSE/Annotated/*.{o,hi} >&! /dev/null++# Can be regenerated by make, if you have Happy installed:+#rm -f HSE/InternalParser.hs >&! /dev/null+
+ freesect.cabal view
@@ -0,0 +1,75 @@+Name: freesect+Version: 0.0.5+Synopsis: A Haskell syntax extension for generalised sections.+Description:+ This package provides an preprocessor executable, \'freesect\', + which implements a generalisation of sections (\'free sections\')+ for partial application and higher-order style. Some examples+ of free sections can be found in the included test suite; refer+ to the homepage for more info. Should be built manually (this+ is very easy; please see the 000-readme file).+Homepage: http://fremissant.net/freesect+License: BSD3+License-file: LICENSE+Author: Andrew Seniuk <rasfar@gmail.com>+Maintainer: Andrew Seniuk <rasfar@gmail.com>+bug-reports: Please send email to the maintainer.+Stability: Provisional+Category: Language+Build-type: Custom+Cabal-version: >= 1.2.3+Extra-source-files:+ -- You may not make use of all of these ones:+ 000-readme, Makefile, cln, freesect.sh, ile, z, zz,+ -- These are example modules containing free sections for testing:+ S14.hs, S15.hs, S23.hs,+ -- Snapshot of documentation; visit the homepage for up-to-date versions:+ Doc/index.html, Doc/irc.html,+ -- The rest are critical for building freesect:+ FilesAndParsing.hs,+ -- Since HSE is not yet patched to include -XFreeSections, we need+ -- to build a patched version locally, hence these dependencies:+ HSE/InternalParser.ly,+ HSE.hs,+ HSE/Annotated.hs,+ HSE/Annotated/Build.hs,+ HSE/Annotated/ExactPrint.hs,+ HSE/Annotated/Fixity.hs,+ HSE/Annotated/Simplify.hs,+ HSE/Annotated/Syntax.hs,+ HSE/Build.hs,+ HSE/Comments.hs,+ HSE/ExtScheme.hs,+ HSE/Extension.hs,+ HSE/Fixity.hs,+ HSE/InternalParser.hs,+ HSE/Lexer.hs,+ HSE/ParseMonad.hs,+ HSE/ParseSyntax.hs,+ HSE/ParseUtils.hs,+ HSE/Parser.hs,+ HSE/Pretty.hs,+ HSE/SrcLoc.hs,+ HSE/Syntax.hs++Executable freesect+ Main-Is: Main.hs+ Build-depends:+ base >= 4.0 && < 5 ,+-- Recommended but not actually needed if the CPP #define PARALLEL is 0.+ parallel >= 3.2.0.2 ,+ syb >= 0.3.6 ,+-- haskell-src-exts >= 1.11.1 ,+-- Since HSE is not yet patched to include -XFreeSections, we need+-- to build a patched version locally, hence these dependencies:+ cpphs >= 1.13.3 ,+ pretty >= 1.0.1.2 ,+ array >= 0.3.0.2 ,+ haskell98 >= 1.1.0.1 ,+ mtl >= 2.0.1.0+ extensions: DeriveDataTypeable, FlexibleContexts, CPP+ Build-tools: happy+ other-modules:+ ghc-options: -O0 -rtsopts -threaded+ cpp-options: -DANNOTATED=0 -DPARALLEL=0 -DGHC_F=1+
+ freesect.sh view
@@ -0,0 +1,13 @@+#!/bin/sh++# # +RTS -p -RTS \+# +RTS -K96m -RTS \+# # +RTS -K16m -RTS \+# # +RTS -i20 -RTS # (default value of granularity of resched. in ms) \+# +RTS -N2 -RTS # Control.Parallel : # of cores (not including hyperthr.) \++./freesect \+ +RTS -N2 -RTS \+ $3 \+ $1+
+ ile view
@@ -0,0 +1,29 @@+#!/bin/csh++ # Turn off the option if its env. var. isn't defined:+ if ( ! $?FS_ANNOTATED ) setenv FS_ANNOTATED 0+ if ( ! $?FS_PARALLEL ) setenv FS_PARALLEL 0+ if ( ! $?FS_GHC_F ) setenv FS_GHC_F 0+echo ANNOTATED=$FS_ANNOTATED+echo PARALLEL=$FS_PARALLEL+echo GHC_F=$FS_GHC_F++ mkdir -p dist/build/freesect/freesect-tmp >&! /dev/null++ ghc --make \+ -idist/build/freesect/freesect-tmp \+ -outputdir dist/build/freesect/freesect-tmp \+# Since 2010 or so, GHC requires this option to use +RTS ... -RTS: \+ -rtsopts \+# For -prof, don't forget you need the +RTS -p -RTS when running \+# -prof \+# -auto-all \+# -ticky \+ -threaded # needed for Control.Concurrent /and/ Control.Parallel \+# -O2 \+ -optP "-DANNOTATED=$FS_ANNOTATED" \+ -optP "-DPARALLEL=$FS_PARALLEL" \+ -optP "-DGHC_F=$FS_GHC_F" \+ Main -o freesect \+##!!+
+ z view
@@ -0,0 +1,128 @@+#!/bin/csh++# Toggle 0/1 to change these options. In particular, if you want+# to use freesect without ghc -F. (This would be necessary in order+# to use a different compiler.)+ setenv FS_ANNOTATED 0+ setenv FS_PARALLEL 0+ setenv FS_GHC_F 1++#set test=S23+ set test=S15+#set test=S14+++make+if ( $? ) exit 1+++if ( $FS_GHC_F ) then+++./zz $test >&! ./zz.log+set zzstat=$?++cat ./zz.log \+# We can also prune these in Main.hs (that's how doing now): \+# |& not |, or won't see these if use "error" b/c goes to stderr \+## |& sed -e 's/SrcLoc {[^}]*}/SrcLoc .../g' \+ |& sed -e 's/SrcLoc {[^}]*}//g' \+## |& sed -e 's/(SrcSpanInfo {[^[][^[]*\[[^]]*]})//g' \+ |& sed -e 's/)))))*/)..)/g' \+##!!++if ( $test == S23 ) then+ echo+ echo+ echo "(Ignore errors about missing symbols; you can examine"+ echo "freesect pre-processor output in the intermediate file.)"+ echo+endif++if ( $zzstat ) exit 1++./$test+++else+++# If you want to run without using "ghc -F", consider the rest+# of this file. Note that there is a #define GHC_F in Main.hs+# for controlling whether or not "ghc -F" is being used.++#================================++set infiles=( \+ ./{$test}.hs \+)++# Must be a legal module name:+ set outfile=Z_`sha1sum $infiles[1] | head -c 8`+#set outfile=Z_`sha1sum $infiles[1] | cut -d' ' -f1`++#echo $infiles+#echo $outfile+#exit+set extra_rtsopts+if ( $FS_PARALLEL ) then+ set extra_rtsopts = ( \+# +RTS -i20 -RTS # (default value of granularity of resched. in ms) \+ +RTS -N2 -RTS # Control.Parallel : # of cores (not including hyperthr.) \+ )+endif++echo freesect infiles=$infiles outfile=$outfile++./freesect \+\+# Don't forget you need the -prof ghc flag when compiling: \+# +RTS -p -RTS \+\+ +RTS -K96m -RTS \+# +RTS -K16m -RTS \+\+ $extra_rtsopts \+\+ $outfile \+\+ $infiles \+\+ >&! ./z.log++set zstat=$?++cat ./z.log \+# We can also prune these in Main.hs (that's how doing now): \+# |& not |, or won't see these if use "error" b/c goes to stderr \+# |& sed -e 's/SrcLoc {[^}]*}/SrcLoc .../g' \+# |& sed -e 's/SrcLoc {[^}]*}//g' \+# |& sed -e 's/(SrcSpanInfo {[^[][^[]*\[[^]]*]})//g' \+ |& sed -e 's/)))))*/)..)/g' \+\+#& \+#!++if ( $zstat ) exit 1 # won't work for Main's exit status, after the pipe++ghc --make {$outfile}.hs -main-is {$outfile}.main -o $outfile++set zstat=$?++if ( $test == S23 ) then+ echo+ echo+ echo "(Ignore errors about missing symbols; you can examine"+ echo "freesect pre-processor output in the intermediate file.)"+ echo+endif++if ( $zstat ) exit 1 # won't work for Main's exit status, after the pipe++./$outfile++#/bin/rm -f {$outfile}.hs+++endif+
+ zz view
@@ -0,0 +1,26 @@+#!/bin/csh++# Supply the name of the main-bearing module, if not ./Main.hs++set main_is="Main"+if ( ${#argv} > 1 ) then+ echo "Too many args; provide at most one module name for -main-is."+ exit 1+else if ( ${#argv} == 1 ) then+ set main_is=$1+endif++echo $main_is+#exit++ghc \+ --make \+ $main_is \+ -main-is $main_is \+ -keep-tmp-files \+ -tmpdir . \+# -fno-warn-unrecognised-pragmas \+ -F -pgmF freesect.sh \+ -o $main_is \+##!!+