{-# OPTIONS_GHC -w #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE PatternGuards #-}
{-# LANGUAGE NoStrictData #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE PartialTypeSignatures #-}
#if __GLASGOW_HASKELL__ >= 710
{-# LANGUAGE PartialTypeSignatures #-}
#endif
module Parser where

import Syntax
import Lexer (Token(..), PosnToken, AlexPosn)
import qualified Data.Function as Happy_Prelude
import qualified Data.Bool as Happy_Prelude
import qualified Data.Function as Happy_Prelude
import qualified Data.Maybe as Happy_Prelude
import qualified Data.Int as Happy_Prelude
import qualified Data.String as Happy_Prelude
import qualified Data.Tuple as Happy_Prelude
import qualified Data.List as Happy_Prelude
import qualified Control.Monad as Happy_Prelude
import qualified Text.Show as Happy_Prelude
import qualified GHC.Num as Happy_Prelude
import qualified GHC.Err as Happy_Prelude
import qualified Data.Array as Happy_Data_Array
import qualified Data.Bits as Bits
import qualified GHC.Exts as Happy_GHC_Exts
import Control.Applicative(Applicative(..))
import Control.Monad (ap)

-- parser produced by Happy Version 2.1.5

data HappyAbsSyn 
        = HappyTerminal ((AlexPosn, Token))
        | HappyErrorToken Happy_Prelude.Int
        | HappyAbsSyn5 (Program)
        | HappyAbsSyn6 ([Decl])
        | HappyAbsSyn7 (Decl)
        | HappyAbsSyn8 ([Ident])
        | HappyAbsSyn9 (Expr)
        | HappyAbsSyn15 ([(Pattern,Expr)])
        | HappyAbsSyn17 ((Pattern,Expr))
        | HappyAbsSyn20 ([Expr])
        | HappyAbsSyn24 ([(BinOperator,Expr)])
        | HappyAbsSyn25 (BinOperator)
        | HappyAbsSyn39 (Literal)
        | HappyAbsSyn46 (Pattern)
        | HappyAbsSyn48 ([Pattern])

{-# NOINLINE happyTokenStrings #-}
happyTokenStrings :: [String]
happyTokenStrings = [String
"\";\"",String
"\"let\"",String
"\"in\"",String
"\"if\"",String
"\"then\"",String
"\"else\"",String
"\"case\"",String
"\"of\"",String
"\"not\"",String
"\"->\"",String
"\"\\\\\"",String
"\"=\"",String
"\"_\"",String
"\"(\"",String
"\")\"",String
"\"[\"",String
"\"]\"",String
"\",\"",String
"\"+\"",String
"\"-\"",String
"\"*\"",String
"\"/\"",String
"\"%\"",String
"\"==\"",String
"\"/=\"",String
"\"<\"",String
"\"<=\"",String
"\">\"",String
"\">=\"",String
"\"&&\"",String
"\"||\"",String
"int",String
"float",String
"char",String
"string",String
"\"True\"",String
"\"False\"",String
"ident",String
"%eof"]

happyActOffsets :: HappyAddr
happyActOffsets :: HappyAddr
happyActOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\xdb\xff\xff\xff\xdb\xff\xff\xff\x00\x00\x00\x00\x09\x00\x00\x00\xf7\xff\xff\xff\x10\x00\x00\x00\x1a\x00\x00\x00\x0a\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x39\x00\x00\x00\x12\x00\x00\x00\x62\x02\x00\x00\x27\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\xca\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\xfe\xff\xff\xff\xfe\xff\xff\xff\xc3\x01\x00\x00\xff\xff\xff\xff\xfe\xff\xff\xff\xfe\xff\xff\xff\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\xf9\xff\xff\xff\x00\x00\x00\x00\x6a\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x83\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\xca\x01\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x75\x00\x00\x00\x79\x00\x00\x00\x28\x00\x00\x00\x62\x02\x00\x00\x2a\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\xfe\xff\xff\xff\xf6\xff\xff\xff\x8a\x00\x00\x00\x8c\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\x8d\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xff\xff\xff\xf6\xff\xff\xff\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\x92\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xa5\x00\x00\x00\xf6\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xff\xff\xff\x00\x00\x00\x00\xa7\x00\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyGotoOffsets :: HappyAddr
happyGotoOffsets :: HappyAddr
happyGotoOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x14\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\xaf\x00\x00\x00\x4c\x00\x00\x00\x4f\x00\x00\x00\x5a\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x4d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x69\x00\x00\x00\x89\x00\x00\x00\x37\x02\x00\x00\x33\x00\x00\x00\xa9\x00\x00\x00\x25\x00\x00\x00\x3e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x02\x00\x00\x00\x00\x00\x00\x45\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x01\x00\x00\x00\x00\x00\x00\xe2\x01\x00\x00\xb6\x00\x00\x00\xb8\x00\x00\x00\x6c\x00\x00\x00\x6f\x00\x00\x00\x7a\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\xe9\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x00\x00\x00\x00\x00\x00\x29\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x01\x00\x00\xad\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x02\x00\x00\xb5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x01\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\x00\x00\x89\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x01\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x02\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyDefActions :: HappyAddr
happyDefActions :: HappyAddr
happyDefActions = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\xfd\xff\xff\xff\xfa\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\xff\xff\x00\x00\x00\x00\xfc\xff\xff\xff\xf9\xff\xff\xff\x00\x00\x00\x00\xfb\xff\xff\xff\xf8\xff\xff\xff\xf7\xff\xff\xff\xf6\xff\xff\xff\xf5\xff\xff\xff\xf4\xff\xff\xff\xe6\xff\xff\xff\xe3\xff\xff\xff\xe0\xff\xff\xff\xdb\xff\xff\xff\xd4\xff\xff\xff\xcf\xff\xff\xff\xc8\xff\xff\xff\xc6\xff\xff\xff\xc4\xff\xff\xff\xc1\xff\xff\xff\xc0\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\xff\xff\x00\x00\x00\x00\xb8\xff\xff\xff\x00\x00\x00\x00\xbf\xff\xff\xff\xbe\xff\xff\xff\xbd\xff\xff\xff\xbc\xff\xff\xff\xbb\xff\xff\xff\xba\xff\xff\xff\xc3\xff\xff\xff\xc9\xff\xff\xff\xb5\xff\xff\xff\x00\x00\x00\x00\xb7\xff\xff\xff\x00\x00\x00\x00\xf2\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xca\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\xff\xff\xff\xc6\xff\xff\xff\xd0\xff\xff\xff\x00\x00\x00\x00\xcd\xff\xff\xff\xcc\xff\xff\xff\xcb\xff\xff\xff\xd5\xff\xff\xff\x00\x00\x00\x00\xd2\xff\xff\xff\xd1\xff\xff\xff\xdc\xff\xff\xff\x00\x00\x00\x00\xd9\xff\xff\xff\xd8\xff\xff\xff\xd7\xff\xff\xff\xd6\xff\xff\xff\xe1\xff\xff\xff\x00\x00\x00\x00\xde\xff\xff\xff\xdd\xff\xff\xff\xe4\xff\xff\xff\x00\x00\x00\x00\xe7\xff\xff\xff\x00\x00\x00\x00\xe6\xff\xff\xff\xe3\xff\xff\xff\xe0\xff\xff\xff\xdb\xff\xff\xff\xd4\xff\xff\xff\xcf\xff\xff\xff\xc5\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xff\xff\xff\x00\x00\x00\x00\xc2\xff\xff\xff\x00\x00\x00\x00\xb9\xff\xff\xff\xb6\xff\xff\xff\x00\x00\x00\x00\xb5\xff\xff\xff\xb2\xff\xff\xff\xf3\xff\xff\xff\x00\x00\x00\x00\xf1\xff\xff\xff\xed\xff\xff\xff\xec\xff\xff\xff\xeb\xff\xff\xff\xae\xff\xff\xff\x00\x00\x00\x00\xad\xff\xff\xff\xac\xff\xff\xff\xb0\xff\xff\xff\x00\x00\x00\x00\xaa\xff\xff\xff\xaf\xff\xff\xff\x00\x00\x00\x00\xe8\xff\xff\xff\xce\xff\xff\xff\xd3\xff\xff\xff\xda\xff\xff\xff\xdf\xff\xff\xff\xe2\xff\xff\xff\xe5\xff\xff\xff\x00\x00\x00\x00\xa7\xff\xff\xff\x00\x00\x00\x00\xa9\xff\xff\xff\xa4\xff\xff\xff\x00\x00\x00\x00\xea\xff\xff\xff\xef\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb4\xff\xff\xff\xb2\xff\xff\xff\xb3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\xff\xff\xff\xa8\xff\xff\xff\x00\x00\x00\x00\xee\xff\xff\xff\xa7\xff\xff\xff\xa4\xff\xff\xff\xa5\xff\xff\xff\xe9\xff\xff\xff\xb1\xff\xff\xff\xa3\xff\xff\xff\xa6\xff\xff\xff"#

happyCheck :: HappyAddr
happyCheck :: HappyAddr
happyCheck = Addr# -> HappyAddr
HappyA# Addr#
"\xff\xff\xff\xff\x03\x00\x00\x00\x27\x00\x00\x00\x05\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x08\x00\x00\x00\x11\x00\x00\x00\x0a\x00\x00\x00\x10\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x13\x00\x00\x00\x0f\x00\x00\x00\x0f\x00\x00\x00\x11\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x27\x00\x00\x00\x0d\x00\x00\x00\x22\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x27\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x2e\x00\x00\x00\x10\x00\x00\x00\x03\x00\x00\x00\x12\x00\x00\x00\x28\x00\x00\x00\x06\x00\x00\x00\x15\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x18\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x1b\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x20\x00\x00\x00\x27\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x16\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x1f\x00\x00\x00\x10\x00\x00\x00\x13\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x15\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x18\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1b\x00\x00\x00\x16\x00\x00\x00\x17\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x12\x00\x00\x00\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x0b\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x27\x00\x00\x00\x10\x00\x00\x00\x09\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x15\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x18\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1b\x00\x00\x00\x16\x00\x00\x00\x17\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x06\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x20\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x1f\x00\x00\x00\x10\x00\x00\x00\x10\x00\x00\x00\x12\x00\x00\x00\x0b\x00\x00\x00\x27\x00\x00\x00\x15\x00\x00\x00\x13\x00\x00\x00\x13\x00\x00\x00\x18\x00\x00\x00\x13\x00\x00\x00\x07\x00\x00\x00\x1b\x00\x00\x00\x13\x00\x00\x00\x12\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x13\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x10\x00\x00\x00\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x13\x00\x00\x00\x02\x00\x00\x00\x10\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x03\x00\x00\x00\x10\x00\x00\x00\x13\x00\x00\x00\x12\x00\x00\x00\x03\x00\x00\x00\x13\x00\x00\x00\x15\x00\x00\x00\x0f\x00\x00\x00\x11\x00\x00\x00\x18\x00\x00\x00\x07\x00\x00\x00\x26\x00\x00\x00\x1b\x00\x00\x00\x0f\x00\x00\x00\x28\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x11\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x07\x00\x00\x00\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x26\x00\x00\x00\x28\x00\x00\x00\x2d\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\x2f\x00\x00\x00\x12\x00\x00\x00\xff\xff\xff\xff\x2f\x00\x00\x00\x15\x00\x00\x00\xff\xff\xff\xff\x2d\x00\x00\x00\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0c\x00\x00\x00\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x0a\x00\x00\x00\x22\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\xff\xff\xff\xff\x0f\x00\x00\x00\xff\xff\xff\xff\x11\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x22\x00\x00\x00\x15\x00\x00\x00\x0f\x00\x00\x00\x2e\x00\x00\x00\x11\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\xff\xff\xff\xff\x2e\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x10\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x15\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x15\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x18\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x18\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x1b\x00\x00\x00\xff\xff\xff\xff\x27\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x22\x00\x00\x00\xff\xff\xff\xff\x22\x00\x00\x00\x27\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x00\x00\x2a\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x22\x00\x00\x00\x2e\x00\x00\x00\xff\xff\xff\xff\x2e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x00\x00\x2a\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x2e\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x27\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x00\x00\x1b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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 :: HappyAddr
happyTable = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x1e\x00\x00\x00\x05\x00\x00\x00\x1f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x20\x00\x00\x00\x72\x00\x00\x00\x21\x00\x00\x00\x5f\x00\x00\x00\x22\x00\x00\x00\x09\x00\x00\x00\x60\x00\x00\x00\x23\x00\x00\x00\x34\x00\x00\x00\x24\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x25\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x73\x00\x00\x00\x08\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x6b\x00\x00\x00\x2d\x00\x00\x00\x0d\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x08\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x6e\x00\x00\x00\x12\x00\x00\x00\x31\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\x32\x00\x00\x00\x14\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x15\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x16\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x51\x00\x00\x00\x1c\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x4f\x00\x00\x00\x12\x00\x00\x00\x63\x00\x00\x00\x13\x00\x00\x00\x09\x00\x00\x00\x03\x00\x00\x00\x14\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x15\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x16\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x36\x00\x00\x00\x0d\x00\x00\x00\x61\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x5e\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x5d\x00\x00\x00\x12\x00\x00\x00\x5b\x00\x00\x00\x13\x00\x00\x00\x37\x00\x00\x00\x03\x00\x00\x00\x14\x00\x00\x00\x78\x00\x00\x00\x4a\x00\x00\x00\x15\x00\x00\x00\x75\x00\x00\x00\x3b\x00\x00\x00\x16\x00\x00\x00\x77\x00\x00\x00\x44\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x5a\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x35\x00\x00\x00\x0d\x00\x00\x00\x59\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x76\x00\x00\x00\x40\x00\x00\x00\x51\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x4f\x00\x00\x00\x12\x00\x00\x00\x68\x00\x00\x00\x13\x00\x00\x00\x81\x00\x00\x00\x5d\x00\x00\x00\x14\x00\x00\x00\x67\x00\x00\x00\x63\x00\x00\x00\x15\x00\x00\x00\x85\x00\x00\x00\x7c\x00\x00\x00\x16\x00\x00\x00\x8e\x00\x00\x00\x8c\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x8b\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x30\x00\x00\x00\x0d\x00\x00\x00\x88\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x85\x00\x00\x00\x93\x00\x00\x00\x92\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x06\x00\x00\x00\x12\x00\x00\x00\x8e\x00\x00\x00\x13\x00\x00\x00\x0a\x00\x00\x00\x8b\x00\x00\x00\x14\x00\x00\x00\x4f\x00\x00\x00\x4d\x00\x00\x00\x15\x00\x00\x00\x5b\x00\x00\x00\x61\x00\x00\x00\x16\x00\x00\x00\x7a\x00\x00\x00\x83\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x79\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x74\x00\x00\x00\x0d\x00\x00\x00\x82\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x85\x00\x00\x00\x93\x00\x00\x00\x8c\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x89\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x73\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x65\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x64\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x63\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x8e\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x88\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x86\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x81\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x21\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x24\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x6b\x00\x00\x00\x25\x00\x00\x00\x23\x00\x00\x00\x6e\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x00\x00\x6d\x00\x00\x00\x7d\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x6d\x00\x00\x00\x90\x00\x00\x00\x6d\x00\x00\x00\x6b\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x18\x00\x00\x00\x6e\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x18\x00\x00\x00\x1c\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x18\x00\x00\x00\x1c\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x57\x00\x00\x00\x39\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyReduceArr :: Array
  Int
  (Int#
   -> (AlexPosn, Token)
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> [(AlexPosn, Token)]
   -> HappyIdentity HappyAbsSyn)
happyReduceArr = (Int, Int)
-> [(Int,
     Int#
     -> (AlexPosn, Token)
     -> Int#
     -> Happy_IntList
     -> HappyStk HappyAbsSyn
     -> [(AlexPosn, Token)]
     -> HappyIdentity HappyAbsSyn)]
-> Array
     Int
     (Int#
      -> (AlexPosn, Token)
      -> Int#
      -> Happy_IntList
      -> HappyStk HappyAbsSyn
      -> [(AlexPosn, Token)]
      -> HappyIdentity HappyAbsSyn)
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
Happy_Data_Array.array (Int
1, Int
92) [
        (Int
1 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_1),
        (Int
2 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_2),
        (Int
3 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_3),
        (Int
4 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_4),
        (Int
5 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_5),
        (Int
6 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_6),
        (Int
7 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_7),
        (Int
8 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_8),
        (Int
9 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_9),
        (Int
10 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_10),
        (Int
11 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_11),
        (Int
12 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_12),
        (Int
13 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_13),
        (Int
14 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_14),
        (Int
15 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_15),
        (Int
16 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_16),
        (Int
17 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_17),
        (Int
18 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_18),
        (Int
19 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_19),
        (Int
20 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_20),
        (Int
21 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_21),
        (Int
22 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_22),
        (Int
23 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_23),
        (Int
24 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_24),
        (Int
25 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_25),
        (Int
26 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_26),
        (Int
27 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_27),
        (Int
28 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_28),
        (Int
29 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_29),
        (Int
30 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_30),
        (Int
31 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_31),
        (Int
32 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_32),
        (Int
33 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_33),
        (Int
34 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_34),
        (Int
35 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_35),
        (Int
36 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_36),
        (Int
37 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_37),
        (Int
38 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_38),
        (Int
39 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_39),
        (Int
40 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_40),
        (Int
41 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_41),
        (Int
42 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_42),
        (Int
43 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_43),
        (Int
44 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_44),
        (Int
45 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_45),
        (Int
46 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_46),
        (Int
47 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_47),
        (Int
48 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_48),
        (Int
49 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_49),
        (Int
50 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_50),
        (Int
51 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_51),
        (Int
52 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_52),
        (Int
53 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_53),
        (Int
54 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_54),
        (Int
55 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_55),
        (Int
56 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_56),
        (Int
57 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_57),
        (Int
58 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_58),
        (Int
59 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_59),
        (Int
60 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_60),
        (Int
61 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_61),
        (Int
62 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_62),
        (Int
63 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_63),
        (Int
64 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_64),
        (Int
65 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_65),
        (Int
66 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_66),
        (Int
67 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_67),
        (Int
68 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_68),
        (Int
69 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_69),
        (Int
70 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_70),
        (Int
71 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_71),
        (Int
72 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_72),
        (Int
73 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_73),
        (Int
74 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_74),
        (Int
75 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_75),
        (Int
76 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_76),
        (Int
77 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_77),
        (Int
78 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_78),
        (Int
79 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_79),
        (Int
80 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_80),
        (Int
81 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_81),
        (Int
82 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_82),
        (Int
83 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_83),
        (Int
84 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_84),
        (Int
85 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_85),
        (Int
86 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_86),
        (Int
87 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_87),
        (Int
88 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_88),
        (Int
89 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_89),
        (Int
90 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_90),
        (Int
91 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_91),
        (Int
92 , Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_92)
        ]

happyRuleArr :: HappyAddr
happyRuleArr :: HappyAddr
happyRuleArr = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x06\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x03\x00\x00\x00\x08\x00\x00\x00\x06\x00\x00\x00\x09\x00\x00\x00\x04\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x02\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x0d\x00\x00\x00\x04\x00\x00\x00\x0e\x00\x00\x00\x02\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x03\x00\x00\x00\x10\x00\x00\x00\x02\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x12\x00\x00\x00\x02\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x14\x00\x00\x00\x01\x00\x00\x00\x14\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x02\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x03\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x02\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x03\x00\x00\x00\x1a\x00\x00\x00\x01\x00\x00\x00\x1a\x00\x00\x00\x01\x00\x00\x00\x1b\x00\x00\x00\x02\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x03\x00\x00\x00\x1d\x00\x00\x00\x01\x00\x00\x00\x1d\x00\x00\x00\x01\x00\x00\x00\x1d\x00\x00\x00\x01\x00\x00\x00\x1e\x00\x00\x00\x02\x00\x00\x00\x1e\x00\x00\x00\x02\x00\x00\x00\x1e\x00\x00\x00\x01\x00\x00\x00\x1f\x00\x00\x00\x02\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x02\x00\x00\x00\x21\x00\x00\x00\x01\x00\x00\x00\x21\x00\x00\x00\x01\x00\x00\x00\x21\x00\x00\x00\x03\x00\x00\x00\x21\x00\x00\x00\x01\x00\x00\x00\x21\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x23\x00\x00\x00\x03\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x24\x00\x00\x00\x01\x00\x00\x00\x25\x00\x00\x00\x02\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x03\x00\x00\x00\x27\x00\x00\x00\x06\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x2a\x00\x00\x00\x03\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x01\x00\x00\x00\x2c\x00\x00\x00\x02\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x03\x00\x00\x00\x2e\x00\x00\x00\x04\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x03\x00\x00\x00"#

happyCatchStates :: [Happy_Prelude.Int]
happyCatchStates :: [Int]
happyCatchStates = []

happy_n_terms :: Int
happy_n_terms = Int
41 :: Happy_Prelude.Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
48 :: Happy_Prelude.Int

happy_n_starts :: Int
happy_n_starts = Int
1 :: Happy_Prelude.Int

happyReduce_1 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_1 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
0# HappyAbsSyn -> HappyAbsSyn
happyReduction_1
happyReduction_1 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_1 (HappyAbsSyn6  [Decl]
happy_var_1)
         =  Program -> HappyAbsSyn
HappyAbsSyn5
                 ([Decl] -> Program
Program ([Decl] -> [Decl]
forall a. [a] -> [a]
reverse [Decl]
happy_var_1)
        )
happyReduction_1 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_2 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_2 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
1# HappyAbsSyn -> HappyAbsSyn
happyReduction_2
happyReduction_2 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_2 (HappyAbsSyn7  Decl
happy_var_1)
         =  [Decl] -> HappyAbsSyn
HappyAbsSyn6
                 ([Decl
happy_var_1]
        )
happyReduction_2 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_3 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_3 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_3
happyReduction_3 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_3 (HappyAbsSyn6  [Decl]
happy_var_3)
        p
_
        (HappyAbsSyn7  Decl
happy_var_1)
         =  [Decl] -> HappyAbsSyn
HappyAbsSyn6
                 (Decl
happy_var_1 Decl -> [Decl] -> [Decl]
forall a. a -> [a] -> [a]
: [Decl]
happy_var_3
        )
happyReduction_3 HappyAbsSyn
_ p
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_4 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_4 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
2# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_4
happyReduction_4 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_4 ((HappyAbsSyn9  Expr
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn8  [String]
happy_var_2) `HappyStk`
        (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1))) `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Decl -> HappyAbsSyn
HappyAbsSyn7
                 (String -> [String] -> Expr -> Decl
FunDecl String
happy_var_1 ([String] -> [String]
forall a. [a] -> [a]
reverse [String]
happy_var_2) Expr
happy_var_4
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_5 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_5 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
3# HappyAbsSyn
happyReduction_5
happyReduction_5 :: HappyAbsSyn
happyReduction_5  =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 ([]
        )

happyReduce_6 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_6 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
3# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_6
happyReduction_6 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_6 (HappyAbsSyn8  [String]
happy_var_2)
        (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1)))
         =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 (String
happy_var_1 String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
happy_var_2
        )
happyReduction_6 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_7 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_7 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
4# HappyAbsSyn -> HappyAbsSyn
happyReduction_7
happyReduction_7 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_7 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_7 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_8 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_8 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
4# HappyAbsSyn -> HappyAbsSyn
happyReduction_8
happyReduction_8 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_8 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_8 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_9 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_9 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
4# HappyAbsSyn -> HappyAbsSyn
happyReduction_9
happyReduction_9 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_9 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_9 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_10 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_10 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
4# HappyAbsSyn -> HappyAbsSyn
happyReduction_10
happyReduction_10 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_10 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_10 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_11 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_11 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
4# HappyAbsSyn -> HappyAbsSyn
happyReduction_11
happyReduction_11 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_11 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_11 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_12 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_12 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
5# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_12
happyReduction_12 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_12 ((HappyAbsSyn9  Expr
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn8  [String]
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Expr -> HappyAbsSyn
HappyAbsSyn9
                 ([String] -> Expr -> Expr
Lambda ([String] -> [String]
forall a. [a] -> [a]
reverse [String]
happy_var_2) Expr
happy_var_4
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_13 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_13 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
6# HappyAbsSyn -> HappyAbsSyn
happyReduction_13
happyReduction_13 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_13 (HappyAbsSyn8  [String]
happy_var_1)
         =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 ([String]
happy_var_1
        )
happyReduction_13 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_14 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_14 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
6# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_14
happyReduction_14 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_14 p
_
        (HappyAbsSyn8  [String]
happy_var_2)
        p
_
         =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 ([String]
happy_var_2
        )
happyReduction_14 p
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_15 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_15 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
7# HappyAbsSyn -> HappyAbsSyn
happyReduction_15
happyReduction_15 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_15 (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1)))
         =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 ([String
happy_var_1]
        )
happyReduction_15 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_16 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_16 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
7# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_16
happyReduction_16 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_16 (HappyAbsSyn8  [String]
happy_var_3)
        p
_
        (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1)))
         =  [String] -> HappyAbsSyn
HappyAbsSyn8
                 (String
happy_var_1 String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
happy_var_3
        )
happyReduction_16 HappyAbsSyn
_ p
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_17 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_17 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
6# Int#
8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_17
happyReduction_17 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_17 ((HappyAbsSyn9  Expr
happy_var_6) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr -> Expr -> Expr -> Expr
If Expr
happy_var_2 Expr
happy_var_4 Expr
happy_var_6
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_18 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_18 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
9# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_18
happyReduction_18 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_18 ((HappyAbsSyn15  [(Pattern, Expr)]
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr -> [(Pattern, Expr)] -> Expr
Case Expr
happy_var_2 [(Pattern, Expr)]
happy_var_4
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_19 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_19 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
10# HappyAbsSyn -> HappyAbsSyn
happyReduction_19
happyReduction_19 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_19 (HappyAbsSyn15  [(Pattern, Expr)]
happy_var_1)
         =  [(Pattern, Expr)] -> HappyAbsSyn
HappyAbsSyn15
                 ([(Pattern, Expr)]
happy_var_1
        )
happyReduction_19 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_20 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_20 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
11# HappyAbsSyn -> HappyAbsSyn
happyReduction_20
happyReduction_20 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_20 (HappyAbsSyn17  (Pattern, Expr)
happy_var_1)
         =  [(Pattern, Expr)] -> HappyAbsSyn
HappyAbsSyn15
                 ([(Pattern, Expr)
happy_var_1]
        )
happyReduction_20 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_21 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_21 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
11# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_21
happyReduction_21 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_21 (HappyAbsSyn17  (Pattern, Expr)
happy_var_2)
        (HappyAbsSyn15  [(Pattern, Expr)]
happy_var_1)
         =  [(Pattern, Expr)] -> HappyAbsSyn
HappyAbsSyn15
                 ([(Pattern, Expr)]
happy_var_1 [(Pattern, Expr)] -> [(Pattern, Expr)] -> [(Pattern, Expr)]
forall a. [a] -> [a] -> [a]
++ [ (Pattern, Expr)
happy_var_2 ]
        )
happyReduction_21 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_22 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_22 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
12# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22
happyReduction_22 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22 (HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_3) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn46  Pattern
happy_var_1) `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = (Pattern, Expr) -> HappyAbsSyn
HappyAbsSyn17
                 ((Pattern
happy_var_1,Expr
happy_var_3)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_23 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_23 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
13# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23
happyReduction_23 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23 ((HappyAbsSyn9  Expr
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn6  [Decl]
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Expr -> HappyAbsSyn
HappyAbsSyn9
                 ([Decl] -> Expr -> Expr
Let ([Decl] -> [Decl]
forall a. [a] -> [a]
reverse [Decl]
happy_var_2) Expr
happy_var_4
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_24 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_24 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
14# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_24
happyReduction_24 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_24 (HappyAbsSyn20  [Expr]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
Or) Expr
happy_var_1 [Expr]
happy_var_2
        )
happyReduction_24 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_25 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_25 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
15# HappyAbsSyn
happyReduction_25
happyReduction_25 :: HappyAbsSyn
happyReduction_25  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_26 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_26 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
15# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_26
happyReduction_26 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_26 (HappyAbsSyn20  [Expr]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_2 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_3
        )
happyReduction_26 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_27 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_27 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
16# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_27
happyReduction_27 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_27 (HappyAbsSyn20  [Expr]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
And) Expr
happy_var_1 [Expr]
happy_var_2
        )
happyReduction_27 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_28 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_28 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
17# HappyAbsSyn
happyReduction_28
happyReduction_28 :: HappyAbsSyn
happyReduction_28  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_29 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_29 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
17# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29
happyReduction_29 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29 (HappyAbsSyn20  [Expr]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_2 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_3
        )
happyReduction_29 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_30 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_30 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
18# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_30
happyReduction_30 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_30 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> (BinOperator, Expr) -> Expr)
-> Expr -> [(BinOperator, Expr)] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Expr
e1 (BinOperator
op,Expr
e2) -> BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
op Expr
e1 Expr
e2) Expr
happy_var_1 [(BinOperator, Expr)]
happy_var_2
        )
happyReduction_30 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_31 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_31 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
19# HappyAbsSyn
happyReduction_31
happyReduction_31 :: HappyAbsSyn
happyReduction_31  =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ([]
        )

happyReduce_32 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_32 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
19# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_32
happyReduction_32 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_32 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        (HappyAbsSyn25  BinOperator
happy_var_1)
         =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ((BinOperator
happy_var_1,Expr
happy_var_2) (BinOperator, Expr)
-> [(BinOperator, Expr)] -> [(BinOperator, Expr)]
forall a. a -> [a] -> [a]
: [(BinOperator, Expr)]
happy_var_3
        )
happyReduction_32 HappyAbsSyn
_ HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_33 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_33 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
20# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_33
happyReduction_33 :: p -> HappyAbsSyn
happyReduction_33 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Eq
        )

happyReduce_34 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_34 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
20# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_34
happyReduction_34 :: p -> HappyAbsSyn
happyReduction_34 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Neq
        )

happyReduce_35 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_35 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
21# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_35
happyReduction_35 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_35 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> (BinOperator, Expr) -> Expr)
-> Expr -> [(BinOperator, Expr)] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Expr
e1 (BinOperator
op,Expr
e2) -> BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
op Expr
e1 Expr
e2) Expr
happy_var_1 [(BinOperator, Expr)]
happy_var_2
        )
happyReduction_35 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_36 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_36 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
22# HappyAbsSyn
happyReduction_36
happyReduction_36 :: HappyAbsSyn
happyReduction_36  =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ([]
        )

happyReduce_37 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_37 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
22# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_37
happyReduction_37 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_37 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        (HappyAbsSyn25  BinOperator
happy_var_1)
         =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ((BinOperator
happy_var_1,Expr
happy_var_2) (BinOperator, Expr)
-> [(BinOperator, Expr)] -> [(BinOperator, Expr)]
forall a. a -> [a] -> [a]
: [(BinOperator, Expr)]
happy_var_3
        )
happyReduction_37 HappyAbsSyn
_ HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_38 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_38 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
23# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_38
happyReduction_38 :: p -> HappyAbsSyn
happyReduction_38 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Lt
        )

happyReduce_39 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_39 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
23# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_39
happyReduction_39 :: p -> HappyAbsSyn
happyReduction_39 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Le
        )

happyReduce_40 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_40 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
23# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_40
happyReduction_40 :: p -> HappyAbsSyn
happyReduction_40 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Gt
        )

happyReduce_41 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_41 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
23# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_41
happyReduction_41 :: p -> HappyAbsSyn
happyReduction_41 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Ge
        )

happyReduce_42 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_42 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
24# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_42
happyReduction_42 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_42 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> (BinOperator, Expr) -> Expr)
-> Expr -> [(BinOperator, Expr)] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Expr
e1 (BinOperator
op,Expr
e2) -> BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
op Expr
e1 Expr
e2) Expr
happy_var_1 [(BinOperator, Expr)]
happy_var_2
        )
happyReduction_42 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_43 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_43 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
25# HappyAbsSyn
happyReduction_43
happyReduction_43 :: HappyAbsSyn
happyReduction_43  =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ([]
        )

happyReduce_44 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_44 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
25# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_44
happyReduction_44 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_44 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        (HappyAbsSyn25  BinOperator
happy_var_1)
         =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ((BinOperator
happy_var_1,Expr
happy_var_2) (BinOperator, Expr)
-> [(BinOperator, Expr)] -> [(BinOperator, Expr)]
forall a. a -> [a] -> [a]
: [(BinOperator, Expr)]
happy_var_3
        )
happyReduction_44 HappyAbsSyn
_ HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_45 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_45 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
26# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_45
happyReduction_45 :: p -> HappyAbsSyn
happyReduction_45 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Add
        )

happyReduce_46 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_46 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
26# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_46
happyReduction_46 :: p -> HappyAbsSyn
happyReduction_46 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Sub
        )

happyReduce_47 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_47 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
27# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_47
happyReduction_47 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_47 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> (BinOperator, Expr) -> Expr)
-> Expr -> [(BinOperator, Expr)] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Expr
e1 (BinOperator
op,Expr
e2) -> BinOperator -> Expr -> Expr -> Expr
BinOp BinOperator
op Expr
e1 Expr
e2) Expr
happy_var_1 [(BinOperator, Expr)]
happy_var_2
        )
happyReduction_47 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_48 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_48 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
28# HappyAbsSyn
happyReduction_48
happyReduction_48 :: HappyAbsSyn
happyReduction_48  =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ([]
        )

happyReduce_49 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_49 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
28# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_49
happyReduction_49 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_49 (HappyAbsSyn24  [(BinOperator, Expr)]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        (HappyAbsSyn25  BinOperator
happy_var_1)
         =  [(BinOperator, Expr)] -> HappyAbsSyn
HappyAbsSyn24
                 ((BinOperator
happy_var_1,Expr
happy_var_2) (BinOperator, Expr)
-> [(BinOperator, Expr)] -> [(BinOperator, Expr)]
forall a. a -> [a] -> [a]
: [(BinOperator, Expr)]
happy_var_3
        )
happyReduction_49 HappyAbsSyn
_ HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_50 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_50 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
29# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_50
happyReduction_50 :: p -> HappyAbsSyn
happyReduction_50 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Mul
        )

happyReduce_51 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_51 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
29# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_51
happyReduction_51 :: p -> HappyAbsSyn
happyReduction_51 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Div
        )

happyReduce_52 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_52 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
29# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_52
happyReduction_52 :: p -> HappyAbsSyn
happyReduction_52 p
_
         =  BinOperator -> HappyAbsSyn
HappyAbsSyn25
                 (BinOperator
Mod
        )

happyReduce_53 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_53 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
30# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_53
happyReduction_53 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_53 (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (UnOperator -> Expr -> Expr
UnOp UnOperator
Not Expr
happy_var_2
        )
happyReduction_53 HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_54 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_54 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
30# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_54
happyReduction_54 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_54 (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (UnOperator -> Expr -> Expr
UnOp UnOperator
Neg Expr
happy_var_2
        )
happyReduction_54 HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_55 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_55 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
30# HappyAbsSyn -> HappyAbsSyn
happyReduction_55
happyReduction_55 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_55 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_55 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_56 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_56 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
31# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_56
happyReduction_56 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_56 (HappyAbsSyn20  [Expr]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ((Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Expr -> Expr -> Expr
App Expr
happy_var_1 [Expr]
happy_var_2
        )
happyReduction_56 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_57 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_57 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
32# HappyAbsSyn
happyReduction_57
happyReduction_57 :: HappyAbsSyn
happyReduction_57  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_58 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_58 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
32# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_58
happyReduction_58 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_58 (HappyAbsSyn20  [Expr]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_1 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_2
        )
happyReduction_58 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_59 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_59 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
33# HappyAbsSyn -> HappyAbsSyn
happyReduction_59
happyReduction_59 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_59 (HappyAbsSyn39  Literal
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Literal -> Expr
Lit Literal
happy_var_1
        )
happyReduction_59 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_60 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_60 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
33# HappyAbsSyn -> HappyAbsSyn
happyReduction_60
happyReduction_60 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_60 (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1)))
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (String -> Expr
Var String
happy_var_1
        )
happyReduction_60 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_61 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_61 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
33# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_61
happyReduction_61 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_61 p
_
        (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_2
        )
happyReduction_61 p
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_62 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_62 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
33# HappyAbsSyn -> HappyAbsSyn
happyReduction_62
happyReduction_62 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_62 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_62 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_63 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_63 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
33# HappyAbsSyn -> HappyAbsSyn
happyReduction_63
happyReduction_63 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_63 (HappyAbsSyn9  Expr
happy_var_1)
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 (Expr
happy_var_1
        )
happyReduction_63 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_64 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_64 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
happyReduction_64
happyReduction_64 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_64 (HappyTerminal ((AlexPosn
_, TokenInt Int
happy_var_1)))
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (Int -> Literal
LInt Int
happy_var_1
        )
happyReduction_64 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_65 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_65 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
happyReduction_65
happyReduction_65 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_65 (HappyTerminal ((AlexPosn
_, TokenFloat Double
happy_var_1)))
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (Double -> Literal
LFloat Double
happy_var_1
        )
happyReduction_65 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_66 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_66 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
happyReduction_66
happyReduction_66 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_66 (HappyTerminal ((AlexPosn
_, TokenChar Char
happy_var_1)))
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (Char -> Literal
LChar Char
happy_var_1
        )
happyReduction_66 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_67 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_67 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
happyReduction_67
happyReduction_67 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_67 (HappyTerminal ((AlexPosn
_, TokenString String
happy_var_1)))
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (String -> Literal
LString String
happy_var_1
        )
happyReduction_67 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_68 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_68 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_68
happyReduction_68 :: p -> HappyAbsSyn
happyReduction_68 p
_
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (Bool -> Literal
LBool Bool
True
        )

happyReduce_69 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_69 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_69
happyReduction_69 :: p -> HappyAbsSyn
happyReduction_69 p
_
         =  Literal -> HappyAbsSyn
HappyAbsSyn39
                 (Bool -> Literal
LBool Bool
False
        )

happyReduce_70 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_70 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
35# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_70
happyReduction_70 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_70 p
_
        (HappyAbsSyn20  [Expr]
happy_var_2)
        p
_
         =  Expr -> HappyAbsSyn
HappyAbsSyn9
                 ([Expr] -> Expr
List [Expr]
happy_var_2
        )
happyReduction_70 p
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_71 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_71 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
36# HappyAbsSyn
happyReduction_71
happyReduction_71 :: HappyAbsSyn
happyReduction_71  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_72 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_72 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
36# HappyAbsSyn -> HappyAbsSyn
happyReduction_72
happyReduction_72 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_72 (HappyAbsSyn20  [Expr]
happy_var_1)
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([Expr]
happy_var_1
        )
happyReduction_72 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_73 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_73 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
37# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_73
happyReduction_73 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_73 (HappyAbsSyn20  [Expr]
happy_var_2)
        (HappyAbsSyn9  Expr
happy_var_1)
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_1 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_2
        )
happyReduction_73 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_74 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_74 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
38# HappyAbsSyn
happyReduction_74
happyReduction_74 :: HappyAbsSyn
happyReduction_74  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_75 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_75 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
38# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_75
happyReduction_75 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_75 (HappyAbsSyn20  [Expr]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_2 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_3
        )
happyReduction_75 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_76 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_76 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
6# Int#
39# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_76
happyReduction_76 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_76 (HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn20  [Expr]
happy_var_5) `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_4) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn9  Expr
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Expr -> HappyAbsSyn
HappyAbsSyn9
                 ([Expr] -> Expr
Tuple (Expr
happy_var_2 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: Expr
happy_var_4 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_5)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_77 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_77 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
40# HappyAbsSyn
happyReduction_77
happyReduction_77 :: HappyAbsSyn
happyReduction_77  =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 ([]
        )

happyReduce_78 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_78 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
40# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_78
happyReduction_78 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_78 (HappyAbsSyn20  [Expr]
happy_var_3)
        (HappyAbsSyn9  Expr
happy_var_2)
        p
_
         =  [Expr] -> HappyAbsSyn
HappyAbsSyn20
                 (Expr
happy_var_2 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
happy_var_3
        )
happyReduction_78 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_79 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_79 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
41# HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn
happyReduction_79
happyReduction_79 :: p -> HappyAbsSyn
happyReduction_79 p
_
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 (Pattern
PWildcard
        )

happyReduce_80 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_80 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
41# HappyAbsSyn -> HappyAbsSyn
happyReduction_80
happyReduction_80 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_80 (HappyTerminal ((AlexPosn
_, TokenIdent String
happy_var_1)))
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 (String -> Pattern
PVar String
happy_var_1
        )
happyReduction_80 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_81 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_81 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
41# HappyAbsSyn -> HappyAbsSyn
happyReduction_81
happyReduction_81 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_81 (HappyAbsSyn39  Literal
happy_var_1)
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 (Literal -> Pattern
PLit Literal
happy_var_1
        )
happyReduction_81 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_82 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_82 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
41# HappyAbsSyn -> HappyAbsSyn
happyReduction_82
happyReduction_82 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_82 (HappyAbsSyn46  Pattern
happy_var_1)
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 (Pattern
happy_var_1
        )
happyReduction_82 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_83 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_83 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
41# HappyAbsSyn -> HappyAbsSyn
happyReduction_83
happyReduction_83 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_83 (HappyAbsSyn46  Pattern
happy_var_1)
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 (Pattern
happy_var_1
        )
happyReduction_83 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_84 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_84 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
42# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_84
happyReduction_84 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_84 p
_
        (HappyAbsSyn48  [Pattern]
happy_var_2)
        p
_
         =  Pattern -> HappyAbsSyn
HappyAbsSyn46
                 ([Pattern] -> Pattern
PList [Pattern]
happy_var_2
        )
happyReduction_84 p
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_85 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_85 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
43# HappyAbsSyn
happyReduction_85
happyReduction_85 :: HappyAbsSyn
happyReduction_85  =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 ([]
        )

happyReduce_86 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_86 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1  Int#
43# HappyAbsSyn -> HappyAbsSyn
happyReduction_86
happyReduction_86 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_86 (HappyAbsSyn48  [Pattern]
happy_var_1)
         =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 ([Pattern]
happy_var_1
        )
happyReduction_86 HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_87 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_87 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2  Int#
44# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_87
happyReduction_87 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_87 (HappyAbsSyn48  [Pattern]
happy_var_2)
        (HappyAbsSyn46  Pattern
happy_var_1)
         =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 (Pattern
happy_var_1 Pattern -> [Pattern] -> [Pattern]
forall a. a -> [a] -> [a]
: [Pattern]
happy_var_2
        )
happyReduction_87 HappyAbsSyn
_ HappyAbsSyn
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_88 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_88 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
45# HappyAbsSyn
happyReduction_88
happyReduction_88 :: HappyAbsSyn
happyReduction_88  =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 ([]
        )

happyReduce_89 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_89 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
45# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_89
happyReduction_89 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_89 (HappyAbsSyn48  [Pattern]
happy_var_3)
        (HappyAbsSyn46  Pattern
happy_var_2)
        p
_
         =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 (Pattern
happy_var_2 Pattern -> [Pattern] -> [Pattern]
forall a. a -> [a] -> [a]
: [Pattern]
happy_var_3
        )
happyReduction_89 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyReduce_90 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_90 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
4# Int#
46# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_90
happyReduction_90 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_90 (HappyAbsSyn
_ `HappyStk`
        (HappyAbsSyn48  [Pattern]
happy_var_3) `HappyStk`
        (HappyAbsSyn46  Pattern
happy_var_2) `HappyStk`
        HappyAbsSyn
_ `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = Pattern -> HappyAbsSyn
HappyAbsSyn46
                 ([Pattern] -> Pattern
PTuple (Pattern
happy_var_2 Pattern -> [Pattern] -> [Pattern]
forall a. a -> [a] -> [a]
: [Pattern]
happy_var_3)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest

happyReduce_91 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_91 = Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0  Int#
47# HappyAbsSyn
happyReduction_91
happyReduction_91 :: HappyAbsSyn
happyReduction_91  =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 ([]
        )

happyReduce_92 :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce_92 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3  Int#
47# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_92
happyReduction_92 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_92 (HappyAbsSyn48  [Pattern]
happy_var_3)
        (HappyAbsSyn46  Pattern
happy_var_2)
        p
_
         =  [Pattern] -> HappyAbsSyn
HappyAbsSyn48
                 (Pattern
happy_var_2 Pattern -> [Pattern] -> [Pattern]
forall a. a -> [a] -> [a]
: [Pattern]
happy_var_3
        )
happyReduction_92 HappyAbsSyn
_ HappyAbsSyn
_ p
_  = HappyAbsSyn
forall a. a
notHappyAtAll 

happyTerminalToTok :: (a, Token) -> Int#
happyTerminalToTok (a, Token)
term = case (a, Token)
term of {
        (a
_, Token
TokenSemi) -> Int#
2#;
        (a
_, Token
TokenLet) -> Int#
3#;
        (a
_, Token
TokenIn) -> Int#
4#;
        (a
_, Token
TokenIf) -> Int#
5#;
        (a
_, Token
TokenThen) -> Int#
6#;
        (a
_, Token
TokenElse) -> Int#
7#;
        (a
_, Token
TokenCase) -> Int#
8#;
        (a
_, Token
TokenOf) -> Int#
9#;
        (a
_, Token
TokenNot) -> Int#
10#;
        (a
_, Token
TokenArrow) -> Int#
11#;
        (a
_, Token
TokenBackslash) -> Int#
12#;
        (a
_, Token
TokenEquals) -> Int#
13#;
        (a
_, Token
TokenUnderscore) -> Int#
14#;
        (a
_, Token
TokenLParen) -> Int#
15#;
        (a
_, Token
TokenRParen) -> Int#
16#;
        (a
_, Token
TokenLBracket) -> Int#
17#;
        (a
_, Token
TokenRBracket) -> Int#
18#;
        (a
_, Token
TokenComma) -> Int#
19#;
        (a
_, Token
TokenPlus) -> Int#
20#;
        (a
_, Token
TokenMinus) -> Int#
21#;
        (a
_, Token
TokenTimes) -> Int#
22#;
        (a
_, Token
TokenDiv) -> Int#
23#;
        (a
_, Token
TokenMod) -> Int#
24#;
        (a
_, Token
TokenEq) -> Int#
25#;
        (a
_, Token
TokenNeq) -> Int#
26#;
        (a
_, Token
TokenLt) -> Int#
27#;
        (a
_, Token
TokenLe) -> Int#
28#;
        (a
_, Token
TokenGt) -> Int#
29#;
        (a
_, Token
TokenGe) -> Int#
30#;
        (a
_, Token
TokenAnd) -> Int#
31#;
        (a
_, Token
TokenOr) -> Int#
32#;
        (a
_, TokenInt Int
happy_dollar_dollar) -> Int#
33#;
        (a
_, TokenFloat Double
happy_dollar_dollar) -> Int#
34#;
        (a
_, TokenChar Char
happy_dollar_dollar) -> Int#
35#;
        (a
_, TokenString String
happy_dollar_dollar) -> Int#
36#;
        (a
_, TokenBool Bool
True) -> Int#
37#;
        (a
_, TokenBool Bool
False) -> Int#
38#;
        (a
_, TokenIdent String
happy_dollar_dollar) -> Int#
39#;
        (a, Token)
_ -> Int#
-1#;
        }
{-# NOINLINE happyTerminalToTok #-}

happyLex :: (t -> [a] -> t)
-> (Int# -> (a, Token) -> [(a, Token)] -> t) -> [(a, Token)] -> t
happyLex t -> [a] -> t
kend  Int# -> (a, Token) -> [(a, Token)] -> t
_kmore []       = t -> [a] -> t
kend t
forall a. a
notHappyAtAll []
happyLex t -> [a] -> t
_kend Int# -> (a, Token) -> [(a, Token)] -> t
kmore  ((a, Token)
tk:[(a, Token)]
tks) = Int# -> (a, Token) -> [(a, Token)] -> t
kmore ((a, Token) -> Int#
forall {a}. (a, Token) -> Int#
happyTerminalToTok (a, Token)
tk) (a, Token)
tk [(a, Token)]
tks
{-# INLINE happyLex #-}

happyNewToken :: Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyNewToken Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk = (Any -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> (Int#
    -> (AlexPosn, Token)
    -> [(AlexPosn, Token)]
    -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {t} {a} {t} {a}.
(t -> [a] -> t)
-> (Int# -> (a, Token) -> [(a, Token)] -> t) -> [(a, Token)] -> t
happyLex (\Any
tk -> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction Int#
40# (AlexPosn, Token)
forall a. a
notHappyAtAll Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk) (\Int#
i (AlexPosn, Token)
tk -> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction Int#
i (AlexPosn, Token)
tk Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk)

happyReport :: Int#
-> (AlexPosn, Token)
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> [(AlexPosn, Token)]
-> HappyIdentity a
happyReport Int#
40# (AlexPosn, Token)
tk [String]
explist [(AlexPosn, Token)] -> HappyIdentity a
resume [(AlexPosn, Token)]
tks = [(AlexPosn, Token)]
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> HappyIdentity a
forall a.
[(AlexPosn, Token)]
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> HappyIdentity a
happyReport' [(AlexPosn, Token)]
tks [String]
explist [(AlexPosn, Token)] -> HappyIdentity a
resume
happyReport Int#
_ (AlexPosn, Token)
tk [String]
explist [(AlexPosn, Token)] -> HappyIdentity a
resume [(AlexPosn, Token)]
tks = [(AlexPosn, Token)]
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> HappyIdentity a
forall a.
[(AlexPosn, Token)]
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> HappyIdentity a
happyReport' ((AlexPosn, Token)
tk(AlexPosn, Token) -> [(AlexPosn, Token)] -> [(AlexPosn, Token)]
forall a. a -> [a] -> [a]
:[(AlexPosn, Token)]
tks) [String]
explist (\[(AlexPosn, Token)]
tks -> [(AlexPosn, Token)] -> HappyIdentity a
resume ([(AlexPosn, Token)] -> [(AlexPosn, Token)]
forall a. [a] -> [a]
Happy_Prelude.tail [(AlexPosn, Token)]
tks))


newtype HappyIdentity a = HappyIdentity a
happyIdentity :: a -> HappyIdentity a
happyIdentity = a -> HappyIdentity a
forall a. a -> HappyIdentity a
HappyIdentity
happyRunIdentity :: HappyIdentity a -> a
happyRunIdentity (HappyIdentity a
a) = a
a

instance Happy_Prelude.Functor HappyIdentity where
    fmap :: forall a b. (a -> b) -> HappyIdentity a -> HappyIdentity b
fmap a -> b
f (HappyIdentity a
a) = b -> HappyIdentity b
forall a. a -> HappyIdentity a
HappyIdentity (a -> b
f a
a)

instance Applicative HappyIdentity where
    pure :: forall a. a -> HappyIdentity a
pure  = a -> HappyIdentity a
forall a. a -> HappyIdentity a
HappyIdentity
    <*> :: forall a b.
HappyIdentity (a -> b) -> HappyIdentity a -> HappyIdentity b
(<*>) = HappyIdentity (a -> b) -> HappyIdentity a -> HappyIdentity b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Happy_Prelude.Monad HappyIdentity where
    return :: forall a. a -> HappyIdentity a
return = a -> HappyIdentity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    (HappyIdentity a
p) >>= :: forall a b.
HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
>>= a -> HappyIdentity b
q = a -> HappyIdentity b
q a
p

happyThen :: () => (HappyIdentity a) -> (a -> (HappyIdentity b)) -> (HappyIdentity b)
happyThen :: forall a b.
HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
happyThen = HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(Happy_Prelude.>>=)
happyReturn :: () => a -> (HappyIdentity a)
happyReturn :: forall a. a -> HappyIdentity a
happyReturn = (a -> HappyIdentity a
forall (m :: * -> *) a. Monad m => a -> m a
Happy_Prelude.return)
happyThen1 :: m t -> (t -> t -> m b) -> t -> m b
happyThen1 m t
m t -> t -> m b
k t
tks = m t -> (t -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(Happy_Prelude.>>=) m t
m (\t
a -> t -> t -> m b
k t
a t
tks)
happyFmap1 :: (t -> b) -> (t -> HappyIdentity t) -> t -> HappyIdentity b
happyFmap1 t -> b
f t -> HappyIdentity t
m t
tks = HappyIdentity t -> (t -> HappyIdentity b) -> HappyIdentity b
forall a b.
HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
happyThen (t -> HappyIdentity t
m t
tks) (\t
a -> b -> HappyIdentity b
forall a. a -> HappyIdentity a
happyReturn (t -> b
f t
a))
happyReturn1 :: () => a -> b -> (HappyIdentity a)
happyReturn1 :: forall a b. a -> b -> HappyIdentity a
happyReturn1 = \a
a b
tks -> (a -> HappyIdentity a
forall (m :: * -> *) a. Monad m => a -> m a
Happy_Prelude.return) a
a
happyReport' :: () => [((AlexPosn, Token))] -> [Happy_Prelude.String] -> ([((AlexPosn, Token))] -> (HappyIdentity a)) -> (HappyIdentity a)
happyReport' :: forall a.
[(AlexPosn, Token)]
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> HappyIdentity a
happyReport' = (\[(AlexPosn, Token)]
tokens [String]
expected [(AlexPosn, Token)] -> HappyIdentity a
resume -> a -> HappyIdentity a
forall a. a -> HappyIdentity a
HappyIdentity (a -> HappyIdentity a) -> a -> HappyIdentity a
forall a b. (a -> b) -> a -> b
Happy_Prelude.$ ([(AlexPosn, Token)] -> a
forall a. [(AlexPosn, Token)] -> a
parseError) [(AlexPosn, Token)]
tokens)

happyAbort :: () => [((AlexPosn, Token))] -> (HappyIdentity a)
happyAbort :: forall a. [(AlexPosn, Token)] -> HappyIdentity a
happyAbort = String -> [(AlexPosn, Token)] -> HappyIdentity a
forall a. HasCallStack => String -> a
Happy_Prelude.error String
"Called abort handler in non-resumptive parser"

parse :: [(AlexPosn, Token)] -> Program
parse [(AlexPosn, Token)]
tks = HappyIdentity Program -> Program
forall {a}. HappyIdentity a -> a
happyRunIdentity HappyIdentity Program
happySomeParser where
 happySomeParser :: HappyIdentity Program
happySomeParser = HappyIdentity HappyAbsSyn
-> (HappyAbsSyn -> HappyIdentity Program) -> HappyIdentity Program
forall a b.
HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
happyThen (Int# -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
happyParse Int#
0# [(AlexPosn, Token)]
tks) (\HappyAbsSyn
x -> case HappyAbsSyn
x of {HappyAbsSyn5 Program
z -> Program -> HappyIdentity Program
forall a. a -> HappyIdentity a
happyReturn Program
z; HappyAbsSyn
_other -> HappyIdentity Program
forall a. a
notHappyAtAll })

happySeq :: a -> b -> b
happySeq = a -> b -> b
forall a b. a -> b -> b
happyDontSeq


parseError :: [PosnToken] -> a
parseError :: forall a. [(AlexPosn, Token)] -> a
parseError ((AlexPosn
pos, Token
tok):[(AlexPosn, Token)]
_) = String -> a
forall a. HasCallStack => String -> a
error (String
"Erro de parse: token inesperado " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Token -> String
forall a. Show a => a -> String
show Token
tok String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" em " String -> String -> String
forall a. [a] -> [a] -> [a]
++ AlexPosn -> String
forall a. Show a => a -> String
show AlexPosn
pos)
parseError []             = String -> a
forall a. HasCallStack => String -> a
error String
"Erro de parse: entrada inesperadamente vazia"
-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $

#if !defined(__GLASGOW_HASKELL__)
#  error This code isn't being built with GHC.
#endif

-- Get WORDS_BIGENDIAN (if defined)
#include "MachDeps.h"

-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Happy_Prelude.Bool)
#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Happy_Prelude.Bool)
#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Happy_Prelude.Bool)
#define PLUS(n,m) (n Happy_GHC_Exts.+# m)
#define MINUS(n,m) (n Happy_GHC_Exts.-# m)
#define TIMES(n,m) (n Happy_GHC_Exts.*# m)
#define NEGATE(n) (Happy_GHC_Exts.negateInt# (n))

type Happy_Int = Happy_GHC_Exts.Int#
data Happy_IntList = HappyCons Happy_Int Happy_IntList

#define INVALID_TOK -1#
#define ERROR_TOK 0#
#define CATCH_TOK 1#

#if defined(HAPPY_COERCE)
#  define GET_ERROR_TOKEN(x)  (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# i) -> i })
#  define MK_ERROR_TOKEN(i)   (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# i))
#  define MK_TOKEN(x)         (happyInTok (x))
#else
#  define GET_ERROR_TOKEN(x)  (case x of { HappyErrorToken (Happy_GHC_Exts.I# i) -> i })
#  define MK_ERROR_TOKEN(i)   (HappyErrorToken (Happy_GHC_Exts.I# i))
#  define MK_TOKEN(x)         (HappyTerminal (x))
#endif

#if defined(HAPPY_DEBUG)
#  define DEBUG_TRACE(s)    (happyTrace (s)) Happy_Prelude.$
happyTrace string expr = Happy_System_IO_Unsafe.unsafePerformIO Happy_Prelude.$ do
    Happy_System_IO.hPutStr Happy_System_IO.stderr string
    Happy_Prelude.return expr
#else
#  define DEBUG_TRACE(s)    {- nothing -}
#endif

infixr 9 `HappyStk`
data HappyStk a = HappyStk a (HappyStk a)

-----------------------------------------------------------------------------
-- starting the parse

happyParse :: Int# -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
happyParse Int#
start_state = Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyNewToken Int#
start_state Happy_IntList
forall a. a
notHappyAtAll HappyStk HappyAbsSyn
forall a. a
notHappyAtAll

-----------------------------------------------------------------------------
-- Accepting the parse

-- If the current token is ERROR_TOK, it means we've just accepted a partial
-- parse (a %partial parser).  We must ignore the saved token on the top of
-- the stack in this case.
happyAccept :: Int# -> p -> Int# -> p -> HappyStk a -> b -> HappyIdentity a
happyAccept ERROR_TOK tk st sts (_ `HappyStk` ans `HappyStk` _) =
        happyReturn1 ans
happyAccept Int#
j p
tk Int#
st p
sts (HappyStk a
ans HappyStk a
_) =
        (Int#
-> ((b -> HappyIdentity a) -> b -> HappyIdentity a)
-> (b -> HappyIdentity a)
-> b
-> HappyIdentity a
forall a. Int# -> a -> a
happyTcHack Int#
j (Int# -> (b -> HappyIdentity a) -> b -> HappyIdentity a
forall a. Int# -> a -> a
happyTcHack Int#
st)) (a -> b -> HappyIdentity a
forall a b. a -> b -> HappyIdentity a
happyReturn1 a
ans)

-----------------------------------------------------------------------------
-- Arrays only: do the next action

happyDoAction :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction Int#
i (AlexPosn, Token)
tk Int#
st =
  DEBUG_TRACE("state: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++
              ",\ttoken: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++
              ",\taction: ")
  case Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st) of
    HappyAction
HappyFail             -> DEBUG_TRACE("failing.\n")
                             Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyFail Int#
i (AlexPosn, Token)
tk Int#
st
    HappyAction
HappyAccept           -> DEBUG_TRACE("accept.\n")
                             Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {p} {p} {a} {b}.
Int# -> p -> Int# -> p -> HappyStk a -> b -> HappyIdentity a
happyAccept Int#
i (AlexPosn, Token)
tk Int#
st
    HappyReduce Int#
rule      -> DEBUG_TRACE("reduce (rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# rule) Happy_Prelude.++ ")")
                             (Array
  Int
  (Int#
   -> (AlexPosn, Token)
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> [(AlexPosn, Token)]
   -> HappyIdentity HappyAbsSyn)
happyReduceArr Array
  Int
  (Int#
   -> (AlexPosn, Token)
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> [(AlexPosn, Token)]
   -> HappyIdentity HappyAbsSyn)
-> Int
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall i e. Ix i => Array i e -> i -> e
Happy_Data_Array.! (Int# -> Int
Happy_GHC_Exts.I# Int#
rule)) Int#
i (AlexPosn, Token)
tk Int#
st
    HappyShift  Int#
new_state -> DEBUG_TRACE("shift, enter state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
                             Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyShift Int#
new_state Int#
i (AlexPosn, Token)
tk Int#
st

{-# INLINE happyNextAction #-}
happyNextAction :: Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st = case Int# -> Int# -> Maybe Int
happyIndexActionTable Int#
i Int#
st of
  Happy_Prelude.Just (Happy_GHC_Exts.I# Int#
act) -> Int#
act
  Maybe Int
Happy_Prelude.Nothing                      -> HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyDefActions Int#
st

{-# INLINE happyIndexActionTable #-}
happyIndexActionTable :: Int# -> Int# -> Maybe Int
happyIndexActionTable Int#
i Int#
st
  | GTE(i, 0#), GTE(off, 0#), EQ(happyIndexOffAddr happyCheck off, i)
  -- i >= 0:   Guard against INVALID_TOK (do the default action, which ultimately errors)
  -- off >= 0: Otherwise it's a default action
  -- equality check: Ensure that the entry in the compressed array is owned by st
  = Int -> Maybe Int
forall a. a -> Maybe a
Happy_Prelude.Just (Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off))
  | Bool
Happy_Prelude.otherwise
  = Maybe Int
forall a. Maybe a
Happy_Prelude.Nothing
  where
    off :: Int#
off = PLUS(happyIndexOffAddr happyActOffsets st, i)

data HappyAction
  = HappyFail
  | HappyAccept
  | HappyReduce Happy_Int -- rule number
  | HappyShift Happy_Int  -- new state
  deriving Int -> HappyAction -> String -> String
[HappyAction] -> String -> String
HappyAction -> String
(Int -> HappyAction -> String -> String)
-> (HappyAction -> String)
-> ([HappyAction] -> String -> String)
-> Show HappyAction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [HappyAction] -> String -> String
$cshowList :: [HappyAction] -> String -> String
show :: HappyAction -> String
$cshow :: HappyAction -> String
showsPrec :: Int -> HappyAction -> String -> String
$cshowsPrec :: Int -> HappyAction -> String -> String
Happy_Prelude.Show

{-# INLINE happyDecodeAction #-}
happyDecodeAction :: Happy_Int -> HappyAction
happyDecodeAction :: Int# -> HappyAction
happyDecodeAction  Int#
0#                        = HappyAction
HappyFail
happyDecodeAction Int#
-1#                        = HappyAction
HappyAccept
happyDecodeAction Int#
action | LT(action, 0#)    = HappyReduce NEGATE(PLUS(action, 1#))
                         | Bool
Happy_Prelude.otherwise = Int# -> HappyAction
HappyShift MINUS(action, 1#)

{-# INLINE happyIndexGotoTable #-}
happyIndexGotoTable :: Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off
  where
    off :: Int#
off = PLUS(happyIndexOffAddr happyGotoOffsets st, nt)

{-# INLINE happyIndexOffAddr #-}
happyIndexOffAddr :: HappyAddr -> Happy_Int -> Happy_Int
happyIndexOffAddr :: HappyAddr -> Int# -> Int#
happyIndexOffAddr (HappyA# Addr#
arr) Int#
off =
#if __GLASGOW_HASKELL__ >= 901
  Happy_GHC_Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
#endif
#ifdef WORDS_BIGENDIAN
  -- The CI of `alex` tests this code path
  (Happy_GHC_Exts.word32ToInt32# (Happy_GHC_Exts.wordToWord32# (Happy_GHC_Exts.byteSwap32# (Happy_GHC_Exts.word32ToWord# (Happy_GHC_Exts.int32ToWord32#
#endif
  (Addr# -> Int# -> Int#
Happy_GHC_Exts.indexInt32OffAddr# Addr#
arr Int#
off)
#ifdef WORDS_BIGENDIAN
  )))))
#endif

happyIndexRuleArr :: Happy_Int -> (# Happy_Int, Happy_Int #)
happyIndexRuleArr :: Int# -> (# Int#, Int# #)
happyIndexRuleArr Int#
r = (# Int#
nt, Int#
len #)
  where
    !(Happy_GHC_Exts.I# Int#
n_starts) = Int
happy_n_starts
    offs :: Int#
offs = TIMES(MINUS(r,n_starts),2#)
    nt :: Int#
nt = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyRuleArr Int#
offs
    len :: Int#
len = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyRuleArr PLUS(offs,1#)

data HappyAddr = HappyA# Happy_GHC_Exts.Addr#

-----------------------------------------------------------------------------
-- Shifting a token

happyShift :: Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyShift Int#
new_state ERROR_TOK tk st sts stk@(x `HappyStk` _) =
     -- See "Error Fixup" below
     let i = GET_ERROR_TOKEN(x) in
     DEBUG_TRACE("shifting the error token")
     happyDoAction i tk new_state (HappyCons st sts) stk

happyShift Int#
new_state Int#
i (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
     Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyNewToken Int#
new_state (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) (MK_TOKEN(tk) `HappyStk` stk)

-- happyReduce is specialised for the common cases.

happySpecReduce_0 :: Int#
-> HappyAbsSyn
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_0 Int#
nt HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
     = HappyAbsSyn
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a b. a -> b -> b
happySeq HappyAbsSyn
fn (Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) (HappyAbsSyn
fn HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
stk))

happySpecReduce_1 :: Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_1 Int#
nt HappyAbsSyn -> HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
old_st sts :: Happy_IntList
sts@(HappyCons Int#
st Happy_IntList
_) (HappyAbsSyn
v1 `HappyStk` HappyStk HappyAbsSyn
stk')
     = let r :: HappyAbsSyn
r = HappyAbsSyn -> HappyAbsSyn
fn HappyAbsSyn
v1 in
       Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
happyTcHack Int#
old_st (HappyAbsSyn
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a b. a -> b -> b
happySeq HappyAbsSyn
r (Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
stk')))

happySpecReduce_2 :: Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_2 Int#
nt HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
old_st
  (HappyCons Int#
_ sts :: Happy_IntList
sts@(HappyCons Int#
st Happy_IntList
_))
  (HappyAbsSyn
v1 `HappyStk` HappyAbsSyn
v2 `HappyStk` HappyStk HappyAbsSyn
stk')
     = let r :: HappyAbsSyn
r = HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
fn HappyAbsSyn
v1 HappyAbsSyn
v2 in
       Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
happyTcHack Int#
old_st (HappyAbsSyn
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a b. a -> b -> b
happySeq HappyAbsSyn
r (Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
stk')))

happySpecReduce_3 :: Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happySpecReduce_3 Int#
nt HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
old_st
  (HappyCons Int#
_ (HappyCons Int#
_ sts :: Happy_IntList
sts@(HappyCons Int#
st Happy_IntList
_)))
  (HappyAbsSyn
v1 `HappyStk` HappyAbsSyn
v2 `HappyStk` HappyAbsSyn
v3 `HappyStk` HappyStk HappyAbsSyn
stk')
     = let r :: HappyAbsSyn
r = HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
fn HappyAbsSyn
v1 HappyAbsSyn
v2 HappyAbsSyn
v3 in
       Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
happyTcHack Int#
old_st (HappyAbsSyn
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a b. a -> b -> b
happySeq HappyAbsSyn
r (Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
stk')))

happyReduce :: Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyReduce Int#
k Int#
nt HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
     = case Int# -> Happy_IntList -> Happy_IntList
happyDrop MINUS(k,(1# :: Happy_Int)) sts of
         sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
                let r :: HappyStk HappyAbsSyn
r = HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
fn HappyStk HappyAbsSyn
stk in -- it doesn't hurt to always seq here...
                Int#
st Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` HappyStk HappyAbsSyn
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a b. a -> b -> b
happyDoSeq HappyStk HappyAbsSyn
r (Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st1 Happy_IntList
sts1 HappyStk HappyAbsSyn
r)

happyMonadReduce :: Int#
-> Int#
-> (HappyStk HappyAbsSyn
    -> (AlexPosn, Token) -> HappyIdentity HappyAbsSyn)
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyMonadReduce Int#
k Int#
nt HappyStk HappyAbsSyn
-> (AlexPosn, Token) -> HappyIdentity HappyAbsSyn
fn Int#
j (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
      case Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
k (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) of
        sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
          let drop_stk :: HappyStk HappyAbsSyn
drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk HappyAbsSyn
stk in
          Int#
j Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` HappyIdentity HappyAbsSyn
-> (HappyAbsSyn
    -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {m :: * -> *} {t} {t} {b}.
Monad m =>
m t -> (t -> t -> m b) -> t -> m b
happyThen1 (HappyStk HappyAbsSyn
-> (AlexPosn, Token) -> HappyIdentity HappyAbsSyn
fn HappyStk HappyAbsSyn
stk (AlexPosn, Token)
tk)
                                     (\HappyAbsSyn
r -> Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st1 Happy_IntList
sts1 (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
drop_stk))

happyMonad2Reduce :: Int#
-> Int#
-> (HappyStk HappyAbsSyn -> t -> HappyIdentity HappyAbsSyn)
-> Int#
-> t
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyMonad2Reduce Int#
k Int#
nt HappyStk HappyAbsSyn -> t -> HappyIdentity HappyAbsSyn
fn Int#
j t
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
      case Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
k (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) of
        sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
          let drop_stk :: HappyStk HappyAbsSyn
drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk HappyAbsSyn
stk
              off :: Int#
off = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyGotoOffsets Int#
st1
              off_i :: Int#
off_i = PLUS(off, nt)
              new_state :: Int#
new_state = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off_i
          in
            Int#
j Int#
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` HappyIdentity HappyAbsSyn
-> (HappyAbsSyn
    -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {m :: * -> *} {t} {t} {b}.
Monad m =>
m t -> (t -> t -> m b) -> t -> m b
happyThen1 (HappyStk HappyAbsSyn -> t -> HappyIdentity HappyAbsSyn
fn HappyStk HappyAbsSyn
stk t
tk)
                                       (\HappyAbsSyn
r -> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyNewToken Int#
new_state Happy_IntList
sts1 (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
drop_stk))

happyDrop :: Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
0# Happy_IntList
l               = Happy_IntList
l
happyDrop Int#
n  (HappyCons Int#
_ Happy_IntList
t) = Int# -> Happy_IntList -> Happy_IntList
happyDrop MINUS(n,(1# :: Happy_Int)) t

happyDropStk :: Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
0# HappyStk a
l                 = HappyStk a
l
happyDropStk Int#
n  (a
x `HappyStk` HappyStk a
xs) = Int# -> HappyStk a -> HappyStk a
happyDropStk MINUS(n,(1#::Happy_Int)) xs

-----------------------------------------------------------------------------
-- Moving to a new state after a reduction

happyGoto :: Int#
-> Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyGoto Int#
nt Int#
j (AlexPosn, Token)
tk Int#
st =
   DEBUG_TRACE(", goto state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
   Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction Int#
j (AlexPosn, Token)
tk Int#
new_state
  where new_state :: Int#
new_state = Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st

{- Note [Error recovery]
~~~~~~~~~~~~~~~~~~~~~~~~
When there is no applicable action for the current lookahead token `tk`,
happy enters error recovery mode. Depending on whether the grammar file
declares the two action form `%error { abort } { report }` for
    Resumptive Error Handling,
it works in one (not resumptive) or two phases (resumptive):

 1. Fixup mode:
    Try to see if there is an action for the error token ERROR_TOK. If there
    is, do *not* emit an error and pretend instead that an `error` token was
    inserted.
    When there is no ERROR_TOK action, report an error.

    In non-resumptive error handling, calling the single error handler
    (e.g. `happyError`) will throw an exception and abort the parser.
    However, in resumptive error handling we enter *error resumption mode*.

 2. Error resumption mode:
    After reporting the error (with `report`), happy will attempt to find
    a good state stack to resume parsing in.
    For each candidate stack, it discards input until one of the candidates
    resumes (i.e. shifts the current input).
    If no candidate resumes before the end of input, resumption failed and
    calls the `abort` function, to much the same effect as in non-resumptive
    error handling.

    Candidate stacks are declared by the grammar author using the special
    `catch` terminal and called "catch frames".
    This mechanism is described in detail in Note [happyResume].

The `catch` resumption mechanism (2) is what usually is associated with
`error` in `bison` or `menhir`. Since `error` is used for the Fixup mechanism
(1) above, we call the corresponding token `catch`.
Furthermore, in constrast to `bison`, our implementation of `catch`
non-deterministically considers multiple catch frames on the stack for
resumption (See Note [Multiple catch frames]).

Note [happyResume]
~~~~~~~~~~~~~~~~~~
`happyResume` implements the resumption mechanism from Note [Error recovery].
It is best understood by example. Consider

Exp :: { String }
Exp : '1'                { "1" }
    | catch              { "catch" }
    | Exp '+' Exp %shift { $1 Happy_Prelude.++ " + " Happy_Prelude.++ $3 } -- %shift: associate 1 + 1 + 1 to the right
    | '(' Exp ')'        { "(" Happy_Prelude.++ $2 Happy_Prelude.++ ")" }

The idea of the use of `catch` here is that upon encountering a parse error
during expression parsing, we can gracefully degrade using the `catch` rule,
still producing a partial syntax tree and keep on parsing to find further
syntax errors.

Let's trace the parser state for input 11+1, which will error out after shifting 1.
After shifting, we have the following item stack (growing downwards and omitting
transitive closure items):

  State 0: %start_parseExp -> . Exp
  State 5: Exp -> '1' .

(Stack as a list of state numbers: [5,0].)
As Note [Error recovery] describes, we will first try Fixup mode.
That fails because no production can shift the `error` token.
Next we try Error resumption mode. This works as follows:

  1. Pop off the item stack until we find an item that can shift the `catch`
     token. (Implemented in `pop_items`.)
       * State 5 cannot shift catch. Pop.
       * State 0 can shift catch, which would transition into
          State 4: Exp -> catch .
     So record the *stack* `[4,0]` after doing the shift transition.
     We call this a *catch frame*, where the top is a *catch state*,
     corresponding to an item in which we just shifted a `catch` token.
     There can be multiple such catch stacks, see Note [Multiple catch frames].

  2. Discard tokens from the input until the lookahead can be shifted in one
     of the catch stacks. (Implemented in `discard_input_until_exp` and
     `some_catch_state_shifts`.)
       * We cannot shift the current lookahead '1' in state 4, so we discard
       * We *can* shift the next lookahead '+' in state 4, but only after
         reducing, which pops State 4 and goes to State 3:
           State 3: %start_parseExp -> Exp .
                    Exp -> Exp . '+' Exp
         Here we can shift '+'.
     As you can see, to implement this machinery we need to simulate
     the operation of the LALR automaton, especially reduction
     (`happySimulateReduce`).

Note [Multiple catch frames]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For fewer spurious error messages, it can be beneficial to trace multiple catch
items. Consider

Exp : '1'
    | catch
    | Exp '+' Exp %shift
    | '(' Exp ')'

Let's trace the parser state for input (;+1, which will error out after shifting (.
After shifting, we have the following item stack (growing downwards):

  State 0: %start_parseExp -> . Exp
  State 6: Exp -> '(' . Exp ')'

Upon error, we want to find items in the stack which can shift a catch token.
Note that both State 0 and State 6 can shift a catch token, transitioning into
  State 4: Exp -> catch .
Hence we record the catch frames `[4,6,0]` and `[4,0]` for possible resumption.

Which catch frame do we pick for resumption?
Note that resuming catch frame `[4,0]` will parse as "catch+1", whereas
resuming the innermost frame `[4,6,0]` corresponds to parsing "(catch+1".
The latter would keep discarding input until the closing ')' is found.
So we will discard + and 1, leading to a spurious syntax error at the end of
input, aborting the parse and never producing a partial syntax tree. Bad!

It is far preferable to resume with catch frame `[4,0]`, where we can resume
successfully on input +, so that is what we do.

In general, we pick the catch frame for resumption that discards the least
amount of input for a successful shift, preferring the topmost such catch frame.
-}

-- happyFail :: Happy_Int -> Token -> Happy_Int -> _
-- This function triggers Note [Error recovery].
-- If the current token is ERROR_TOK, phase (1) has failed and we might try
-- phase (2).
happyFail :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyFail ERROR_TOK = happyFixupFailed
happyFail Int#
i         = Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyTryFixup Int#
i

-- Enter Error Fixup (see Note [Error recovery]):
-- generate an error token, save the old token and carry on.
-- When a `happyShift` accepts the error token, we will pop off the error token
-- to resume parsing with the current lookahead `i`.
happyTryFixup :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyTryFixup Int#
i (AlexPosn, Token)
tk Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk =
  DEBUG_TRACE("entering `error` fixup.\n")
  Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction ERROR_TOK tk action sts (MK_ERROR_TOKEN(i) `HappyStk` stk)
  -- NB: `happyShift` will simply pop the error token and carry on with
  --     `tk`. Hence we don't change `tk` in the call here

-- See Note [Error recovery], phase (2).
-- Enter resumption mode after reporting the error by calling `happyResume`.
happyFixupFailed :: (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyFixupFailed (AlexPosn, Token)
tk Int#
st Happy_IntList
sts (HappyAbsSyn
x `HappyStk` HappyStk HappyAbsSyn
stk) =
  let i :: Int#
i = GET_ERROR_TOKEN(x) in
  DEBUG_TRACE("`error` fixup failed.\n")
  let resume :: [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
resume   = Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyResume Int#
i (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
      expected :: [String]
expected = Int# -> Happy_IntList -> [String]
happyExpectedTokens Int#
st Happy_IntList
sts in
  Int#
-> (AlexPosn, Token)
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {a}.
Int#
-> (AlexPosn, Token)
-> [String]
-> ([(AlexPosn, Token)] -> HappyIdentity a)
-> [(AlexPosn, Token)]
-> HappyIdentity a
happyReport Int#
i (AlexPosn, Token)
tk [String]
expected [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
resume

-- happyResume :: Happy_Int -> Token -> Happy_Int -> _
-- See Note [happyResume]
happyResume :: Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyResume Int#
i (AlexPosn, Token)
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk = [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
pop_items [] Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
  where
    !(Happy_GHC_Exts.I# Int#
n_starts) = Int
happy_n_starts   -- this is to test whether we have a start token
    !(Happy_GHC_Exts.I# Int#
eof_i) = Int
happy_n_terms Int -> Int -> Int
forall a. Num a => a -> a -> a
Happy_Prelude.- Int
1   -- this is the token number of the EOF token
    happy_list_to_list :: Happy_IntList -> [Happy_Prelude.Int]
    happy_list_to_list :: Happy_IntList -> [Int]
happy_list_to_list (HappyCons Int#
st Happy_IntList
sts)
      | LT(st, n_starts)
      = [(Int# -> Int
Happy_GHC_Exts.I# Int#
st)]
      | Bool
Happy_Prelude.otherwise
      = (Int# -> Int
Happy_GHC_Exts.I# Int#
st) Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Happy_IntList -> [Int]
happy_list_to_list Happy_IntList
sts

    -- See (1) of Note [happyResume]
    pop_items :: [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
      | LT(st, n_starts)
      = DEBUG_TRACE("reached start state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", ")
        if [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new
          then DEBUG_TRACE("no resumption.\n")
               [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
forall a. [(AlexPosn, Token)] -> HappyIdentity a
happyAbort
          else DEBUG_TRACE("now discard input, trying to anchor in states " Happy_Prelude.++ Happy_Prelude.show (Happy_Prelude.map (happy_list_to_list . Happy_Prelude.fst) (Happy_Prelude.reverse catch_frames_new)) Happy_Prelude.++ ".\n")
               Int#
-> (AlexPosn, Token)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
discard_input_until_exp Int#
i (AlexPosn, Token)
tk ([(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
forall a. [a] -> [a]
Happy_Prelude.reverse [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new)
      | (HappyCons Int#
st1 Happy_IntList
sts1) <- Happy_IntList
sts, HappyAbsSyn
_ `HappyStk` HappyStk HappyAbsSyn
stk1 <- HappyStk HappyAbsSyn
stk
      = [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new Int#
st1 Happy_IntList
sts1 HappyStk HappyAbsSyn
stk1
      where
        !catch_frames_new :: [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new
          | HappyShift Int#
new_state <- Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction CATCH_TOK st)
          , DEBUG_TRACE("can shift catch token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", into state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
            [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null (((Happy_IntList, HappyStk HappyAbsSyn) -> Bool)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
forall a. (a -> Bool) -> [a] -> [a]
Happy_Prelude.filter (\(HappyCons Int#
_ (HappyCons Int#
h Happy_IntList
_),HappyStk HappyAbsSyn
_) -> EQ(st,h)) catch_frames)
          = (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
new_state (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts), MK_ERROR_TOKEN(i) `HappyStk` stk):catch_frames -- MK_ERROR_TOKEN(i) is just some dummy that should not be accessed by user code
          | Bool
Happy_Prelude.otherwise
          = DEBUG_TRACE("already shifted or can't shift catch in " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ "\n")
            [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames

    -- See (2) of Note [happyResume]
    discard_input_until_exp :: Int#
-> (AlexPosn, Token)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
discard_input_until_exp Int#
i (AlexPosn, Token)
tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames
      | Happy_Prelude.Just (HappyCons Int#
st (HappyCons Int#
catch_st Happy_IntList
sts), HappyStk HappyAbsSyn
catch_frame) <- Int#
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Maybe (Happy_IntList, HappyStk HappyAbsSyn)
forall {b}.
Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
some_catch_state_shifts Int#
i [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames
      = DEBUG_TRACE("found expected token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ " after shifting from " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# catch_st) Happy_Prelude.++ ": " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
        Int#
-> (AlexPosn, Token)
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
happyDoAction Int#
i (AlexPosn, Token)
tk Int#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
catch_st Happy_IntList
sts) HappyStk HappyAbsSyn
catch_frame
      | EQ(i,eof_i) -- is i EOF?
      = DEBUG_TRACE("reached EOF, cannot resume. abort parse :(\n")
        [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn
forall a. [(AlexPosn, Token)] -> HappyIdentity a
happyAbort
      | Bool
Happy_Prelude.otherwise
      = DEBUG_TRACE("discard token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
        ((AlexPosn, Token)
 -> [(AlexPosn, Token)] -> HappyIdentity HappyAbsSyn)
-> (Int#
    -> (AlexPosn, Token)
    -> [(AlexPosn, Token)]
    -> HappyIdentity HappyAbsSyn)
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
forall {t} {a} {t} {a}.
(t -> [a] -> t)
-> (Int# -> (a, Token) -> [(a, Token)] -> t) -> [(a, Token)] -> t
happyLex (\(AlexPosn, Token)
eof_tk -> Int#
-> (AlexPosn, Token)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
discard_input_until_exp Int#
eof_i (AlexPosn, Token)
eof_tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames) -- eof
                 (\Int#
i (AlexPosn, Token)
tk   -> Int#
-> (AlexPosn, Token)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(AlexPosn, Token)]
-> HappyIdentity HappyAbsSyn
discard_input_until_exp Int#
i (AlexPosn, Token)
tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames)         -- not eof

    some_catch_state_shifts :: Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
some_catch_state_shifts Int#
_ [] = DEBUG_TRACE("no catch state could shift.\n") Happy_Prelude.Nothing
    some_catch_state_shifts Int#
i catch_frames :: [(Happy_IntList, b)]
catch_frames@(((HappyCons Int#
st Happy_IntList
sts),b
_):[(Happy_IntList, b)]
_) = Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st Happy_IntList
sts [(Happy_IntList, b)]
catch_frames
      where
        try_head :: Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st Happy_IntList
sts [(Happy_IntList, b)]
catch_frames = -- PRECONDITION: head catch_frames = (HappyCons st sts)
          DEBUG_TRACE("trying token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ " in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ": ")
          case Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st) of
            HappyAction
HappyFail     -> DEBUG_TRACE("fail.\n")   some_catch_state_shifts i (Happy_Prelude.tail catch_frames)
            HappyAction
HappyAccept   -> DEBUG_TRACE("accept.\n") Happy_Prelude.Just (Happy_Prelude.head catch_frames)
            HappyShift Int#
_  -> DEBUG_TRACE("shift.\n")  Happy_Prelude.Just (Happy_Prelude.head catch_frames)
            HappyReduce Int#
r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts of
              (HappyCons Int#
st1 Happy_IntList
sts1) -> Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st1 Happy_IntList
sts1 [(Happy_IntList, b)]
catch_frames

happySimulateReduce :: Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts =
  DEBUG_TRACE("simulate reduction of rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# r) Happy_Prelude.++ ", ")
  let (# Int#
nt, Int#
len #) = Int# -> (# Int#, Int# #)
happyIndexRuleArr Int#
r in
  DEBUG_TRACE("nt " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# nt) Happy_Prelude.++ ", len: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# len) Happy_Prelude.++ ", new_st ")
  let !(sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_)) = Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
len (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts)
      new_st :: Int#
new_st = Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st1 in
  DEBUG_TRACE(Happy_Prelude.show (Happy_GHC_Exts.I# new_st) Happy_Prelude.++ ".\n")
  (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
new_st Happy_IntList
sts1)

happyTokenToString :: Happy_Prelude.Int -> Happy_Prelude.String
happyTokenToString :: Int -> String
happyTokenToString Int
i = [String]
happyTokenStrings [String] -> Int -> String
forall a. [a] -> Int -> a
Happy_Prelude.!! (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
Happy_Prelude.- Int
2) -- 2: errorTok, catchTok

happyExpectedTokens :: Happy_Int -> Happy_IntList -> [Happy_Prelude.String]
-- Upon a parse error, we want to suggest tokens that are expected in that
-- situation. This function computes such tokens.
-- It works by examining the top of the state stack.
-- For every token number that does a shift transition, record that token number.
-- For every token number that does a reduce transition, simulate that reduction
-- on the state state stack and repeat.
-- The recorded token numbers are then formatted with 'happyTokenToString' and
-- returned.
happyExpectedTokens :: Int# -> Happy_IntList -> [String]
happyExpectedTokens Int#
st Happy_IntList
sts =
  DEBUG_TRACE("constructing expected tokens.\n")
  (Int -> String) -> [Int] -> [String]
forall a b. (a -> b) -> [a] -> [b]
Happy_Prelude.map Int -> String
happyTokenToString (Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st Happy_IntList
sts [])
  where
    search_shifts :: Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st Happy_IntList
sts [Int]
shifts = ((Int, Int) -> [Int] -> [Int]) -> [Int] -> [(Int, Int)] -> [Int]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Happy_Prelude.foldr (Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
add_action Int#
st Happy_IntList
sts) [Int]
shifts (Int# -> [(Int, Int)]
distinct_actions Int#
st)
    add_action :: Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
add_action Int#
st Happy_IntList
sts (Happy_GHC_Exts.I# Int#
i, Happy_GHC_Exts.I# Int#
act) [Int]
shifts =
      DEBUG_TRACE("found action in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", input " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ ", " Happy_Prelude.++ Happy_Prelude.show (happyDecodeAction act) Happy_Prelude.++ "\n")
      case Int# -> HappyAction
happyDecodeAction Int#
act of
        HappyAction
HappyFail     -> [Int]
shifts
        HappyAction
HappyAccept   -> [Int]
shifts -- This would always be %eof or error... Not helpful
        HappyShift Int#
_  -> Int -> [Int] -> [Int]
forall a. Ord a => a -> [a] -> [a]
Happy_Prelude.insert (Int# -> Int
Happy_GHC_Exts.I# Int#
i) [Int]
shifts
        HappyReduce Int#
r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts of
          (HappyCons Int#
st1 Happy_IntList
sts1) -> Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st1 Happy_IntList
sts1 [Int]
shifts
    distinct_actions :: Int# -> [(Int, Int)]
distinct_actions Int#
st
      -- The (token number, action) pairs of all actions in the given state
      = ((-Int
1), (Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyDefActions Int#
st)))
      (Int, Int) -> [(Int, Int)] -> [(Int, Int)]
forall a. a -> [a] -> [a]
: [ (Int
i, Int
act) | Int
i <- [Int
begin_i..Int
happy_n_terms], Int
act <- Int# -> Int -> [Int]
get_act Int#
row_off Int
i ]
      where
        row_off :: Int#
row_off = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyActOffsets Int#
st
        begin_i :: Int
begin_i = Int
2 -- +2: errorTok,catchTok
    get_act :: Int# -> Int -> [Int]
get_act Int#
off (Happy_GHC_Exts.I# Int#
i) -- happyIndexActionTable with cached row offset
      | let off_i :: Int#
off_i = PLUS(off,i)
      , GTE(off_i,0#)
      , EQ(happyIndexOffAddr happyCheck off_i,i)
      = [(Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off_i))]
      | Bool
Happy_Prelude.otherwise
      = []

-- Internal happy errors:

notHappyAtAll :: a
notHappyAtAll :: forall a. a
notHappyAtAll = String -> a
forall a. HasCallStack => String -> a
Happy_Prelude.error String
"Internal Happy parser panic. This is not supposed to happen! Please open a bug report at https://github.com/haskell/happy/issues.\n"

-----------------------------------------------------------------------------
-- Hack to get the typechecker to accept our action functions

happyTcHack :: Happy_Int -> a -> a
happyTcHack :: forall a. Int# -> a -> a
happyTcHack Int#
x a
y = a
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 :: forall a b. a -> b -> b
happyDoSeq   a
a b
b = a
a a -> b -> b
`Happy_GHC_Exts.seq` b
b
happyDontSeq :: forall a b. a -> b -> b
happyDontSeq a
a b
b = 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.