{-# OPTIONS_GHC -w #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE PatternGuards #-}
{-# LANGUAGE NoStrictData #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE Trustworthy #-}

module Config.NumberParser where

import Data.List (foldl')
import Config.Number
import qualified Control.Monad as Happy_Prelude
import qualified Data.Bool as Happy_Prelude
import qualified Data.Function as Happy_Prelude
import qualified Data.Int as Happy_Prelude
import qualified Data.List as Happy_Prelude
import qualified Data.Maybe as Happy_Prelude
import qualified Data.String as Happy_Prelude
import qualified Data.Tuple as Happy_Prelude
import qualified GHC.Err as Happy_Prelude
import qualified GHC.Num as Happy_Prelude
import qualified Text.Show 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.7

newtype HappyAbsSyn t6 t13 = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
newtype HappyWrap5 = HappyWrap5 (Number)
happyIn5 :: (Number) -> (HappyAbsSyn t6 t13)
happyIn5 :: forall t6 t13. Number -> HappyAbsSyn t6 t13
happyIn5 Number
x = HappyWrap5 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Number -> HappyWrap5
HappyWrap5 Number
x)
{-# INLINE happyIn5 #-}
happyOut5 :: (HappyAbsSyn t6 t13) -> HappyWrap5
happyOut5 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap5
happyOut5 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap5
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut5 #-}
happyIn6 :: t6 -> (HappyAbsSyn t6 t13)
happyIn6 :: forall t6 t13. t6 -> HappyAbsSyn t6 t13
happyIn6 t6
x = t6 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# t6
x
{-# INLINE happyIn6 #-}
happyOut6 :: (HappyAbsSyn t6 t13) -> t6
happyOut6 :: forall t6 t13. HappyAbsSyn t6 t13 -> t6
happyOut6 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> t6
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut6 #-}
newtype HappyWrap7 = HappyWrap7 (Integer)
happyIn7 :: (Integer) -> (HappyAbsSyn t6 t13)
happyIn7 :: forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn7 Integer
x = HappyWrap7 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Integer -> HappyWrap7
HappyWrap7 Integer
x)
{-# INLINE happyIn7 #-}
happyOut7 :: (HappyAbsSyn t6 t13) -> HappyWrap7
happyOut7 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap7
happyOut7 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap7
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut7 #-}
newtype HappyWrap8 = HappyWrap8 ([Int])
happyIn8 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn8 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn8 [Int]
x = HappyWrap8 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap8
HappyWrap8 [Int]
x)
{-# INLINE happyIn8 #-}
happyOut8 :: (HappyAbsSyn t6 t13) -> HappyWrap8
happyOut8 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap8
happyOut8 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap8
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut8 #-}
newtype HappyWrap9 = HappyWrap9 ([Int])
happyIn9 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn9 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn9 [Int]
x = HappyWrap9 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap9
HappyWrap9 [Int]
x)
{-# INLINE happyIn9 #-}
happyOut9 :: (HappyAbsSyn t6 t13) -> HappyWrap9
happyOut9 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap9
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut9 #-}
newtype HappyWrap10 = HappyWrap10 ([Int])
happyIn10 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn10 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn10 [Int]
x = HappyWrap10 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap10
HappyWrap10 [Int]
x)
{-# INLINE happyIn10 #-}
happyOut10 :: (HappyAbsSyn t6 t13) -> HappyWrap10
happyOut10 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap10
happyOut10 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap10
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut10 #-}
newtype HappyWrap11 = HappyWrap11 ([Int])
happyIn11 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn11 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn11 [Int]
x = HappyWrap11 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap11
HappyWrap11 [Int]
x)
{-# INLINE happyIn11 #-}
happyOut11 :: (HappyAbsSyn t6 t13) -> HappyWrap11
happyOut11 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap11
happyOut11 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap11
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut11 #-}
newtype HappyWrap12 = HappyWrap12 (Int)
happyIn12 :: (Int) -> (HappyAbsSyn t6 t13)
happyIn12 :: forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12 Int
x = HappyWrap12 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Int -> HappyWrap12
HappyWrap12 Int
x)
{-# INLINE happyIn12 #-}
happyOut12 :: (HappyAbsSyn t6 t13) -> HappyWrap12
happyOut12 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap12
happyOut12 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap12
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut12 #-}
happyIn13 :: t13 -> (HappyAbsSyn t6 t13)
happyIn13 :: forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13 t13
x = t13 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# t13
x
{-# INLINE happyIn13 #-}
happyOut13 :: (HappyAbsSyn t6 t13) -> t13
happyOut13 :: forall t6 t13. HappyAbsSyn t6 t13 -> t13
happyOut13 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut13 #-}
newtype HappyWrap14 = HappyWrap14 (Int)
happyIn14 :: (Int) -> (HappyAbsSyn t6 t13)
happyIn14 :: forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14 Int
x = HappyWrap14 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Int -> HappyWrap14
HappyWrap14 Int
x)
{-# INLINE happyIn14 #-}
happyOut14 :: (HappyAbsSyn t6 t13) -> HappyWrap14
happyOut14 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap14
happyOut14 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap14
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut14 #-}
newtype HappyWrap15 = HappyWrap15 (Int)
happyIn15 :: (Int) -> (HappyAbsSyn t6 t13)
happyIn15 :: forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn15 Int
x = HappyWrap15 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Int -> HappyWrap15
HappyWrap15 Int
x)
{-# INLINE happyIn15 #-}
happyOut15 :: (HappyAbsSyn t6 t13) -> HappyWrap15
happyOut15 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap15
happyOut15 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap15
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut15 #-}
newtype HappyWrap16 = HappyWrap16 (Integer)
happyIn16 :: (Integer) -> (HappyAbsSyn t6 t13)
happyIn16 :: forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn16 Integer
x = HappyWrap16 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Integer -> HappyWrap16
HappyWrap16 Integer
x)
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn t6 t13) -> HappyWrap16
happyOut16 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap16
happyOut16 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap16
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut16 #-}
newtype HappyWrap17 = HappyWrap17 (Integer)
happyIn17 :: (Integer) -> (HappyAbsSyn t6 t13)
happyIn17 :: forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn17 Integer
x = HappyWrap17 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Integer -> HappyWrap17
HappyWrap17 Integer
x)
{-# INLINE happyIn17 #-}
happyOut17 :: (HappyAbsSyn t6 t13) -> HappyWrap17
happyOut17 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap17
happyOut17 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap17
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut17 #-}
newtype HappyWrap18 = HappyWrap18 ([Int])
happyIn18 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn18 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn18 [Int]
x = HappyWrap18 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap18
HappyWrap18 [Int]
x)
{-# INLINE happyIn18 #-}
happyOut18 :: (HappyAbsSyn t6 t13) -> HappyWrap18
happyOut18 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap18
happyOut18 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap18
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut18 #-}
newtype HappyWrap19 = HappyWrap19 ([Int])
happyIn19 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn19 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn19 [Int]
x = HappyWrap19 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap19
HappyWrap19 [Int]
x)
{-# INLINE happyIn19 #-}
happyOut19 :: (HappyAbsSyn t6 t13) -> HappyWrap19
happyOut19 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap19
happyOut19 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap19
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut19 #-}
newtype HappyWrap20 = HappyWrap20 ([Int])
happyIn20 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn20 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn20 [Int]
x = HappyWrap20 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap20
HappyWrap20 [Int]
x)
{-# INLINE happyIn20 #-}
happyOut20 :: (HappyAbsSyn t6 t13) -> HappyWrap20
happyOut20 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap20
happyOut20 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap20
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut20 #-}
newtype HappyWrap21 = HappyWrap21 ([Int])
happyIn21 :: ([Int]) -> (HappyAbsSyn t6 t13)
happyIn21 :: forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn21 [Int]
x = HappyWrap21 -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Int] -> HappyWrap21
HappyWrap21 [Int]
x)
{-# INLINE happyIn21 #-}
happyOut21 :: (HappyAbsSyn t6 t13) -> HappyWrap21
happyOut21 :: forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap21
happyOut21 HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> HappyWrap21
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOut21 #-}
happyInTok :: (Char) -> (HappyAbsSyn t6 t13)
happyInTok :: forall t6 t13. Char -> HappyAbsSyn t6 t13
happyInTok Char
x = Char -> HappyAbsSyn t6 t13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# Char
x
{-# INLINE happyInTok #-}
happyOutTok :: (HappyAbsSyn t6 t13) -> (Char)
happyOutTok :: forall t6 t13. HappyAbsSyn t6 t13 -> Char
happyOutTok HappyAbsSyn t6 t13
x = HappyAbsSyn t6 t13 -> Char
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn t6 t13
x
{-# INLINE happyOutTok #-}


{-# NOINLINE happyTokenStrings #-}
happyTokenStrings :: [String]
happyTokenStrings = [String
"'+'",String
"'-'",String
"'.'",String
"'0'",String
"'1'",String
"'2'",String
"'3'",String
"'4'",String
"'5'",String
"'6'",String
"'7'",String
"'8'",String
"'9'",String
"'A'",String
"'B'",String
"'C'",String
"'D'",String
"'E'",String
"'F'",String
"'O'",String
"'P'",String
"'X'",String
"%eof"]

happyActOffsets :: HappyAddr
happyActOffsets :: HappyAddr
happyActOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x2c\x00\x00\x00\x21\x00\x00\x00\x41\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x69\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\xfd\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x4b\x00\x00\x00\x4b\x00\x00\x00\x4b\x00\x00\x00\x4b\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x69\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyGotoOffsets :: HappyAddr
happyGotoOffsets :: HappyAddr
happyGotoOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x63\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x83\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x77\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x00\x00\x91\x00\x00\x00\x93\x00\x00\x00\x7c\x00\x00\x00\x7c\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x9b\x00\x00\x00\x8e\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\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xff\xff\xc2\xff\xff\xff\xf3\xff\xff\xff\xdd\xff\xff\xff\xdc\xff\xff\xff\xdb\xff\xff\xff\xda\xff\xff\xff\xd9\xff\xff\xff\xd8\xff\xff\xff\xd7\xff\xff\xff\xd6\xff\xff\xff\xd5\xff\xff\xff\xd4\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\xff\xff\xc9\xff\xff\xff\xc1\xff\xff\xff\xdd\xff\xff\xff\xfe\xff\xff\xff\xc0\xff\xff\xff\xfb\xff\xff\xff\x00\x00\x00\x00\xbf\xff\xff\xff\xf5\xff\xff\xff\xed\xff\xff\xff\xec\xff\xff\xff\xeb\xff\xff\xff\xea\xff\xff\xff\xe9\xff\xff\xff\xe8\xff\xff\xff\xe7\xff\xff\xff\xe6\xff\xff\xff\xe5\xff\xff\xff\xe4\xff\xff\xff\xe3\xff\xff\xff\xe2\xff\xff\xff\xe1\xff\xff\xff\xe0\xff\xff\xff\xdf\xff\xff\xff\xde\xff\xff\xff\xbc\xff\xff\xff\xf1\xff\xff\xff\xd3\xff\xff\xff\xd2\xff\xff\xff\xd1\xff\xff\xff\xd0\xff\xff\xff\xcf\xff\xff\xff\xce\xff\xff\xff\xcd\xff\xff\xff\xcc\xff\xff\xff\xc5\xff\xff\xff\xef\xff\xff\xff\xcb\xff\xff\xff\xca\xff\xff\xff\xee\xff\xff\xff\xf9\xff\xff\xff\xc4\xff\xff\xff\xf0\xff\xff\xff\xfa\xff\xff\xff\xbb\xff\xff\xff\xf4\xff\xff\xff\xc7\xff\xff\xff\xbe\xff\xff\xff\xc8\xff\xff\xff\xf6\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xff\xff\xf8\xff\xff\xff\xbd\xff\xff\xff\xfc\xff\xff\xff\x00\x00\x00\x00\xba\xff\xff\xff\xc3\xff\xff\xff\xc6\xff\xff\xff"#

happyCheck :: HappyAddr
happyCheck :: HappyAddr
happyCheck = Addr# -> HappyAddr
HappyA# Addr#
"\xff\xff\xff\xff\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x03\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x16\x00\x00\x00\x13\x00\x00\x00\x08\x00\x00\x00\x08\x00\x00\x00\x0f\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x0b\x00\x00\x00\x04\x00\x00\x00\x15\x00\x00\x00\x08\x00\x00\x00\x17\x00\x00\x00\x08\x00\x00\x00\x10\x00\x00\x00\x02\x00\x00\x00\x08\x00\x00\x00\x04\x00\x00\x00\x0c\x00\x00\x00\x08\x00\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x0e\x00\x00\x00\x05\x00\x00\x00\x0a\x00\x00\x00\x03\x00\x00\x00\x06\x00\x00\x00\x09\x00\x00\x00\x04\x00\x00\x00\x07\x00\x00\x00\x0a\x00\x00\x00\x05\x00\x00\x00\x08\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x09\x00\x00\x00\x04\x00\x00\x00\x07\x00\x00\x00\x04\x00\x00\x00\x0a\x00\x00\x00\x08\x00\x00\x00\x0a\x00\x00\x00\x08\x00\x00\x00\xff\xff\xff\xff\x0d\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\xff\xff\xff\xff\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x45\x00\x00\x00\x1f\x00\x00\x00\x20\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\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x1f\x00\x00\x00\x20\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\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x03\x00\x00\x00\x18\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\xff\xff\xff\xff\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x18\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x42\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x42\x00\x00\x00\x45\x00\x00\x00\x05\x00\x00\x00\x46\x00\x00\x00\x4e\x00\x00\x00\x1c\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x43\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x12\x00\x00\x00\x18\x00\x00\x00\x3f\x00\x00\x00\x1a\x00\x00\x00\x05\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x14\x00\x00\x00\x06\x00\x00\x00\x40\x00\x00\x00\x50\x00\x00\x00\x14\x00\x00\x00\x46\x00\x00\x00\x4c\x00\x00\x00\x14\x00\x00\x00\x38\x00\x00\x00\x06\x00\x00\x00\x15\x00\x00\x00\x2e\x00\x00\x00\x39\x00\x00\x00\x1c\x00\x00\x00\x4f\x00\x00\x00\x2f\x00\x00\x00\x19\x00\x00\x00\x1d\x00\x00\x00\x39\x00\x00\x00\x4e\x00\x00\x00\x06\x00\x00\x00\x4b\x00\x00\x00\x42\x00\x00\x00\x2f\x00\x00\x00\x4a\x00\x00\x00\x1d\x00\x00\x00\x49\x00\x00\x00\x3c\x00\x00\x00\x06\x00\x00\x00\x3c\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3f\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#
   -> Char
   -> Int#
   -> Happy_IntList
   -> HappyStk (HappyAbsSyn Number Int)
   -> String
   -> HappyIdentity (HappyAbsSyn Number Int))
happyReduceArr = (Int, Int)
-> [(Int,
     Int#
     -> Char
     -> Int#
     -> Happy_IntList
     -> HappyStk (HappyAbsSyn Number Int)
     -> String
     -> HappyIdentity (HappyAbsSyn Number Int))]
-> Array
     Int
     (Int#
      -> Char
      -> Int#
      -> Happy_IntList
      -> HappyStk (HappyAbsSyn Number Int)
      -> String
      -> HappyIdentity (HappyAbsSyn Number Int))
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
Happy_Data_Array.array (Int
1, Int
69) [
        (Int
1 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_1),
        (Int
2 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_2),
        (Int
3 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_3),
        (Int
4 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_4),
        (Int
5 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_5),
        (Int
6 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_6),
        (Int
7 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_7),
        (Int
8 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_8),
        (Int
9 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_9),
        (Int
10 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_10),
        (Int
11 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_11),
        (Int
12 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_12),
        (Int
13 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_13),
        (Int
14 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_14),
        (Int
15 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_15),
        (Int
16 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_16),
        (Int
17 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_17),
        (Int
18 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_18),
        (Int
19 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_19),
        (Int
20 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_20),
        (Int
21 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_21),
        (Int
22 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_22),
        (Int
23 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_23),
        (Int
24 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_24),
        (Int
25 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_25),
        (Int
26 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_26),
        (Int
27 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_27),
        (Int
28 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_28),
        (Int
29 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_29),
        (Int
30 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_30),
        (Int
31 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_31),
        (Int
32 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_32),
        (Int
33 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_33),
        (Int
34 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_34),
        (Int
35 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_35),
        (Int
36 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_36),
        (Int
37 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_37),
        (Int
38 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_38),
        (Int
39 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_39),
        (Int
40 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_40),
        (Int
41 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_41),
        (Int
42 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_42),
        (Int
43 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_43),
        (Int
44 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_44),
        (Int
45 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_45),
        (Int
46 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_46),
        (Int
47 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_47),
        (Int
48 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_48),
        (Int
49 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_49),
        (Int
50 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_50),
        (Int
51 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_51),
        (Int
52 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_52),
        (Int
53 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_53),
        (Int
54 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_54),
        (Int
55 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_55),
        (Int
56 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_56),
        (Int
57 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_57),
        (Int
58 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_58),
        (Int
59 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_59),
        (Int
60 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_60),
        (Int
61 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_61),
        (Int
62 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_62),
        (Int
63 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_63),
        (Int
64 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_64),
        (Int
65 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_65),
        (Int
66 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_66),
        (Int
67 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_67),
        (Int
68 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_68),
        (Int
69 , Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_69)
        ]

happyRuleArr :: HappyAddr
happyRuleArr :: HappyAddr
happyRuleArr = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x02\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x02\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x01\x00\x00\x00\x0d\x00\x00\x00\x02\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x01\x00\x00\x00\x0e\x00\x00\x00\x02\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x0f\x00\x00\x00\x02\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x02\x00\x00\x00"#

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

happy_n_terms :: Int
happy_n_terms = Int
25 :: Happy_Prelude.Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
17 :: Happy_Prelude.Int

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

happyReduce_1 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_1 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
0# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6} {t13}.
HappyAbsSyn Number t13 -> p -> HappyAbsSyn t6 t13
happyReduction_1
happyReduction_1 :: HappyAbsSyn Number t13 -> p -> HappyAbsSyn t6 t13
happyReduction_1 HappyAbsSyn Number t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn Number t13 -> Number
forall t6 t13. HappyAbsSyn t6 t13 -> t6
happyOut6 HappyAbsSyn Number t13
happy_x_2 of { Number
happy_var_2 -> 
        Number -> HappyAbsSyn t6 t13
forall t6 t13. Number -> HappyAbsSyn t6 t13
happyIn5
                 (Number -> Number
negNum Number
happy_var_2
        )}

happyReduce_2 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_2 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
0# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {t6} {t13}.
HappyAbsSyn Number t13 -> HappyAbsSyn t6 t13
happyReduction_2
happyReduction_2 :: HappyAbsSyn Number t13 -> HappyAbsSyn t6 t13
happyReduction_2 HappyAbsSyn Number t13
happy_x_1
         =  case HappyAbsSyn Number t13 -> Number
forall t6 t13. HappyAbsSyn t6 t13 -> t6
happyOut6 HappyAbsSyn Number t13
happy_x_1 of { Number
happy_var_1 -> 
        Number -> HappyAbsSyn t6 t13
forall t6 t13. Number -> HappyAbsSyn t6 t13
happyIn5
                 (Number
happy_var_1
        )}

happyReduce_3 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_3 = Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> HappyStk (HappyAbsSyn Number Int))
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce Int#
5# Int#
1# HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall {t13}.
HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_3
happyReduction_3 :: HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_3 (HappyAbsSyn Number t13
happy_x_5 `HappyStk`
        HappyAbsSyn Number t13
happy_x_4 `HappyStk`
        HappyAbsSyn Number t13
happy_x_3 `HappyStk`
        HappyAbsSyn Number t13
happy_x_2 `HappyStk`
        HappyAbsSyn Number t13
happy_x_1 `HappyStk`
        HappyStk (HappyAbsSyn Number t13)
happyRest)
         = case HappyAbsSyn Number t13 -> HappyWrap8
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap8
happyOut8 HappyAbsSyn Number t13
happy_x_3 of { (HappyWrap8 [Int]
happy_var_3) -> 
        case HappyAbsSyn Number t13 -> HappyWrap20
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap20
happyOut20 HappyAbsSyn Number t13
happy_x_4 of { (HappyWrap20 [Int]
happy_var_4) -> 
        case HappyAbsSyn Number t13 -> HappyWrap17
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap17
happyOut17 HappyAbsSyn Number t13
happy_x_5 of { (HappyWrap17 Integer
happy_var_5) -> 
        Number -> HappyAbsSyn Number t13
forall t6 t13. t6 -> HappyAbsSyn t6 t13
happyIn6
                 (Radix -> [Int] -> [Int] -> Number
mkNum (Integer -> Radix
Radix16 Integer
happy_var_5) [Int]
happy_var_3 [Int]
happy_var_4
        ) HappyAbsSyn Number t13
-> HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number t13)
happyRest}}}

happyReduce_4 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_4 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_3  Int#
1# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int
-> HappyAbsSyn Number Int
-> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13} {t6} {t13} {t13}.
HappyAbsSyn t6 t13
-> HappyAbsSyn t6 t13
-> HappyAbsSyn t6 t13
-> HappyAbsSyn Number t13
happyReduction_4
happyReduction_4 :: HappyAbsSyn t6 t13
-> HappyAbsSyn t6 t13
-> HappyAbsSyn t6 t13
-> HappyAbsSyn Number t13
happyReduction_4 HappyAbsSyn t6 t13
happy_x_3
        HappyAbsSyn t6 t13
happy_x_2
        HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap9 [Int]
happy_var_1) -> 
        case HappyAbsSyn t6 t13 -> HappyWrap19
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap19
happyOut19 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap19 [Int]
happy_var_2) -> 
        case HappyAbsSyn t6 t13 -> HappyWrap16
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap16
happyOut16 HappyAbsSyn t6 t13
happy_x_3 of { (HappyWrap16 Integer
happy_var_3) -> 
        Number -> HappyAbsSyn Number t13
forall t6 t13. t6 -> HappyAbsSyn t6 t13
happyIn6
                 (Radix -> [Int] -> [Int] -> Number
mkNum (Integer -> Radix
Radix10 Integer
happy_var_3) [Int]
happy_var_1 [Int]
happy_var_2
        )}}}

happyReduce_5 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_5 = Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> HappyStk (HappyAbsSyn Number Int))
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce Int#
4# Int#
1# HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall {t13}.
HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_5
happyReduction_5 :: HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_5 (HappyAbsSyn Number t13
happy_x_4 `HappyStk`
        HappyAbsSyn Number t13
happy_x_3 `HappyStk`
        HappyAbsSyn Number t13
happy_x_2 `HappyStk`
        HappyAbsSyn Number t13
happy_x_1 `HappyStk`
        HappyStk (HappyAbsSyn Number t13)
happyRest)
         = case HappyAbsSyn Number t13 -> HappyWrap10
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap10
happyOut10 HappyAbsSyn Number t13
happy_x_3 of { (HappyWrap10 [Int]
happy_var_3) -> 
        case HappyAbsSyn Number t13 -> HappyWrap21
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap21
happyOut21 HappyAbsSyn Number t13
happy_x_4 of { (HappyWrap21 [Int]
happy_var_4) -> 
        Number -> HappyAbsSyn Number t13
forall t6 t13. t6 -> HappyAbsSyn t6 t13
happyIn6
                 (Radix -> [Int] -> [Int] -> Number
mkNum Radix
Radix8 [Int]
happy_var_3 [Int]
happy_var_4
        ) HappyAbsSyn Number t13
-> HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number t13)
happyRest}}

happyReduce_6 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_6 = Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> HappyStk (HappyAbsSyn Number Int))
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce Int#
4# Int#
1# HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall {t13}.
HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_6
happyReduction_6 :: HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
happyReduction_6 (HappyAbsSyn Number t13
happy_x_4 `HappyStk`
        HappyAbsSyn Number t13
happy_x_3 `HappyStk`
        HappyAbsSyn Number t13
happy_x_2 `HappyStk`
        HappyAbsSyn Number t13
happy_x_1 `HappyStk`
        HappyStk (HappyAbsSyn Number t13)
happyRest)
         = case HappyAbsSyn Number t13 -> HappyWrap11
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap11
happyOut11 HappyAbsSyn Number t13
happy_x_3 of { (HappyWrap11 [Int]
happy_var_3) -> 
        case HappyAbsSyn Number t13 -> HappyWrap18
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap18
happyOut18 HappyAbsSyn Number t13
happy_x_4 of { (HappyWrap18 [Int]
happy_var_4) -> 
        Number -> HappyAbsSyn Number t13
forall t6 t13. t6 -> HappyAbsSyn t6 t13
happyIn6
                 (Radix -> [Int] -> [Int] -> Number
mkNum Radix
Radix2 [Int]
happy_var_3 [Int]
happy_var_4
        ) HappyAbsSyn Number t13
-> HappyStk (HappyAbsSyn Number t13)
-> HappyStk (HappyAbsSyn Number t13)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number t13)
happyRest}}

happyReduce_7 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_7 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
2# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_7
happyReduction_7 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_7 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap9 [Int]
happy_var_2) -> 
        Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn7
                 (Int -> [Int] -> Integer
toInt Int
10 [Int]
happy_var_2
        )}

happyReduce_8 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_8 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
2# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_8
happyReduction_8 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_8 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap9 [Int]
happy_var_2) -> 
        Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn7
                 (- Int -> [Int] -> Integer
toInt Int
10 [Int]
happy_var_2
        )}

happyReduce_9 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_9 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
2# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_9
happyReduction_9 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_9 HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap9 [Int]
happy_var_1) -> 
        Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn7
                 (Int -> [Int] -> Integer
toInt Int
10 [Int]
happy_var_1
        )}

happyReduce_10 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_10 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
3# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_10
happyReduction_10 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_10 HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap12
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap12
happyOut12 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap12 Int
happy_var_1) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn8
                 ([Int
happy_var_1]
        )}

happyReduce_11 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_11 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
3# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_11
happyReduction_11 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_11 HappyAbsSyn t6 t13
happy_x_2
        HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap8
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap8
happyOut8 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap8 [Int]
happy_var_1) -> 
        case HappyAbsSyn t6 t13 -> HappyWrap12
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap12
happyOut12 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap12 Int
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn8
                 (Int
happy_var_2 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
happy_var_1
        )}}

happyReduce_12 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_12 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
4# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t6} {t13}. HappyAbsSyn t6 Int -> HappyAbsSyn t6 t13
happyReduction_12
happyReduction_12 :: HappyAbsSyn t6 Int -> HappyAbsSyn t6 t13
happyReduction_12 HappyAbsSyn t6 Int
happy_x_1
         =  case HappyAbsSyn t6 Int -> Int
forall t6 t13. HappyAbsSyn t6 t13 -> t13
happyOut13 HappyAbsSyn t6 Int
happy_x_1 of { Int
happy_var_1 -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn9
                 ([Int
happy_var_1]
        )}

happyReduce_13 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_13 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
4# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 Int -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_13
happyReduction_13 :: HappyAbsSyn t6 Int -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_13 HappyAbsSyn t6 Int
happy_x_2
        HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap9 [Int]
happy_var_1) -> 
        case HappyAbsSyn t6 Int -> Int
forall t6 t13. HappyAbsSyn t6 t13 -> t13
happyOut13 HappyAbsSyn t6 Int
happy_x_2 of { Int
happy_var_2 -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn9
                 (Int
happy_var_2 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
happy_var_1
        )}}

happyReduce_14 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_14 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
5# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_14
happyReduction_14 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_14 HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap14
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap14
happyOut14 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap14 Int
happy_var_1) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn10
                 ([Int
happy_var_1]
        )}

happyReduce_15 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_15 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
5# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_15
happyReduction_15 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_15 HappyAbsSyn t6 t13
happy_x_2
        HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap10
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap10
happyOut10 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap10 [Int]
happy_var_1) -> 
        case HappyAbsSyn t6 t13 -> HappyWrap14
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap14
happyOut14 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap14 Int
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn10
                 (Int
happy_var_2 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
happy_var_1
        )}}

happyReduce_16 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_16 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
6# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_16
happyReduction_16 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_16 HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap15
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap15
happyOut15 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap15 Int
happy_var_1) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn11
                 ([Int
happy_var_1]
        )}

happyReduce_17 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_17 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
6# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {t6} {t13} {t6} {t13}.
HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_17
happyReduction_17 :: HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13 -> HappyAbsSyn t6 t13
happyReduction_17 HappyAbsSyn t6 t13
happy_x_2
        HappyAbsSyn t6 t13
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap11
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap11
happyOut11 HappyAbsSyn t6 t13
happy_x_1 of { (HappyWrap11 [Int]
happy_var_1) -> 
        case HappyAbsSyn t6 t13 -> HappyWrap15
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap15
happyOut15 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap15 Int
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn11
                 (Int
happy_var_2 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
happy_var_1
        )}}

happyReduce_18 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_18 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_18
happyReduction_18 :: p -> HappyAbsSyn t6 t13
happyReduction_18 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
0
        )

happyReduce_19 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_19 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_19
happyReduction_19 :: p -> HappyAbsSyn t6 t13
happyReduction_19 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
1
        )

happyReduce_20 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_20 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_20
happyReduction_20 :: p -> HappyAbsSyn t6 t13
happyReduction_20 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
2
        )

happyReduce_21 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_21 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_21
happyReduction_21 :: p -> HappyAbsSyn t6 t13
happyReduction_21 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
3
        )

happyReduce_22 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_22 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_22
happyReduction_22 :: p -> HappyAbsSyn t6 t13
happyReduction_22 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
4
        )

happyReduce_23 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_23 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_23
happyReduction_23 :: p -> HappyAbsSyn t6 t13
happyReduction_23 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
5
        )

happyReduce_24 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_24 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_24
happyReduction_24 :: p -> HappyAbsSyn t6 t13
happyReduction_24 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
6
        )

happyReduce_25 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_25 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_25
happyReduction_25 :: p -> HappyAbsSyn t6 t13
happyReduction_25 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
7
        )

happyReduce_26 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_26 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_26
happyReduction_26 :: p -> HappyAbsSyn t6 t13
happyReduction_26 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
8
        )

happyReduce_27 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_27 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_27
happyReduction_27 :: p -> HappyAbsSyn t6 t13
happyReduction_27 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
9
        )

happyReduce_28 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_28 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_28
happyReduction_28 :: p -> HappyAbsSyn t6 t13
happyReduction_28 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
10
        )

happyReduce_29 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_29 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_29
happyReduction_29 :: p -> HappyAbsSyn t6 t13
happyReduction_29 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
11
        )

happyReduce_30 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_30 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_30
happyReduction_30 :: p -> HappyAbsSyn t6 t13
happyReduction_30 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
12
        )

happyReduce_31 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_31 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_31
happyReduction_31 :: p -> HappyAbsSyn t6 t13
happyReduction_31 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
13
        )

happyReduce_32 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_32 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_32
happyReduction_32 :: p -> HappyAbsSyn t6 t13
happyReduction_32 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
14
        )

happyReduce_33 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_33 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
7# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_33
happyReduction_33 :: p -> HappyAbsSyn t6 t13
happyReduction_33 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn12
                 (Int
15
        )

happyReduce_34 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_34 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_34
happyReduction_34 :: p -> HappyAbsSyn t6 t13
happyReduction_34 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
0
        )

happyReduce_35 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_35 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_35
happyReduction_35 :: p -> HappyAbsSyn t6 t13
happyReduction_35 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
1
        )

happyReduce_36 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_36 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_36
happyReduction_36 :: p -> HappyAbsSyn t6 t13
happyReduction_36 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
2
        )

happyReduce_37 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_37 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_37
happyReduction_37 :: p -> HappyAbsSyn t6 t13
happyReduction_37 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
3
        )

happyReduce_38 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_38 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_38
happyReduction_38 :: p -> HappyAbsSyn t6 t13
happyReduction_38 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
4
        )

happyReduce_39 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_39 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_39
happyReduction_39 :: p -> HappyAbsSyn t6 t13
happyReduction_39 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
5
        )

happyReduce_40 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_40 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_40
happyReduction_40 :: p -> HappyAbsSyn t6 t13
happyReduction_40 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
6
        )

happyReduce_41 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_41 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_41
happyReduction_41 :: p -> HappyAbsSyn t6 t13
happyReduction_41 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
7
        )

happyReduce_42 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_42 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_42
happyReduction_42 :: p -> HappyAbsSyn t6 t13
happyReduction_42 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
8
        )

happyReduce_43 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_43 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
8# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t13} {p} {t6}. Num t13 => p -> HappyAbsSyn t6 t13
happyReduction_43
happyReduction_43 :: p -> HappyAbsSyn t6 t13
happyReduction_43 p
happy_x_1
         =  t13 -> HappyAbsSyn t6 t13
forall t13 t6. t13 -> HappyAbsSyn t6 t13
happyIn13
                 (t13
9
        )

happyReduce_44 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_44 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_44
happyReduction_44 :: p -> HappyAbsSyn t6 t13
happyReduction_44 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
0
        )

happyReduce_45 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_45 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_45
happyReduction_45 :: p -> HappyAbsSyn t6 t13
happyReduction_45 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
1
        )

happyReduce_46 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_46 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_46
happyReduction_46 :: p -> HappyAbsSyn t6 t13
happyReduction_46 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
2
        )

happyReduce_47 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_47 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_47
happyReduction_47 :: p -> HappyAbsSyn t6 t13
happyReduction_47 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
3
        )

happyReduce_48 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_48 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_48
happyReduction_48 :: p -> HappyAbsSyn t6 t13
happyReduction_48 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
4
        )

happyReduce_49 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_49 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_49
happyReduction_49 :: p -> HappyAbsSyn t6 t13
happyReduction_49 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
5
        )

happyReduce_50 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_50 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_50
happyReduction_50 :: p -> HappyAbsSyn t6 t13
happyReduction_50 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
6
        )

happyReduce_51 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_51 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
9# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_51
happyReduction_51 :: p -> HappyAbsSyn t6 t13
happyReduction_51 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn14
                 (Int
7
        )

happyReduce_52 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_52 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
10# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_52
happyReduction_52 :: p -> HappyAbsSyn t6 t13
happyReduction_52 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn15
                 (Int
0
        )

happyReduce_53 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_53 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
10# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_53
happyReduction_53 :: p -> HappyAbsSyn t6 t13
happyReduction_53 p
happy_x_1
         =  Int -> HappyAbsSyn t6 t13
forall t6 t13. Int -> HappyAbsSyn t6 t13
happyIn15
                 (Int
1
        )

happyReduce_54 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_54 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
11# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_54
happyReduction_54 :: HappyAbsSyn t6 t13
happyReduction_54  =  Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn16
                 (Integer
0
        )

happyReduce_55 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_55 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
11# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_55
happyReduction_55 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_55 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap7
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap7
happyOut7 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap7 Integer
happy_var_2) -> 
        Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn16
                 (Integer
happy_var_2
        )}

happyReduce_56 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_56 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
12# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_56
happyReduction_56 :: HappyAbsSyn t6 t13
happyReduction_56  =  Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn17
                 (Integer
0
        )

happyReduce_57 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_57 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
12# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_57
happyReduction_57 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_57 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap7
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap7
happyOut7 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap7 Integer
happy_var_2) -> 
        Integer -> HappyAbsSyn t6 t13
forall t6 t13. Integer -> HappyAbsSyn t6 t13
happyIn17
                 (Integer
happy_var_2
        )}

happyReduce_58 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_58 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
13# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_58
happyReduction_58 :: HappyAbsSyn t6 t13
happyReduction_58  =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn18
                 ([]
        )

happyReduce_59 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_59 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
13# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_59
happyReduction_59 :: p -> HappyAbsSyn t6 t13
happyReduction_59 p
happy_x_1
         =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn18
                 ([]
        )

happyReduce_60 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_60 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
13# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_60
happyReduction_60 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_60 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap11
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap11
happyOut11 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap11 [Int]
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn18
                 ([Int]
happy_var_2
        )}

happyReduce_61 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_61 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
14# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_61
happyReduction_61 :: HappyAbsSyn t6 t13
happyReduction_61  =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn19
                 ([]
        )

happyReduce_62 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_62 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
14# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_62
happyReduction_62 :: p -> HappyAbsSyn t6 t13
happyReduction_62 p
happy_x_1
         =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn19
                 ([]
        )

happyReduce_63 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_63 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
14# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_63
happyReduction_63 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_63 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap9
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap9
happyOut9 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap9 [Int]
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn19
                 ([Int]
happy_var_2
        )}

happyReduce_64 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_64 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
15# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_64
happyReduction_64 :: HappyAbsSyn t6 t13
happyReduction_64  =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn20
                 ([]
        )

happyReduce_65 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_65 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
15# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_65
happyReduction_65 :: p -> HappyAbsSyn t6 t13
happyReduction_65 p
happy_x_1
         =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn20
                 ([]
        )

happyReduce_66 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_66 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
15# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_66
happyReduction_66 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_66 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap8
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap8
happyOut8 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap8 [Int]
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn20
                 ([Int]
happy_var_2
        )}

happyReduce_67 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_67 = Int#
-> HappyAbsSyn Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0  Int#
16# HappyAbsSyn Number Int
forall {t6} {t13}. HappyAbsSyn t6 t13
happyReduction_67
happyReduction_67 :: HappyAbsSyn t6 t13
happyReduction_67  =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn21
                 ([]
        )

happyReduce_68 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_68 = Int#
-> (HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_1  Int#
16# HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {p} {t6} {t13}. p -> HappyAbsSyn t6 t13
happyReduction_68
happyReduction_68 :: p -> HappyAbsSyn t6 t13
happyReduction_68 p
happy_x_1
         =  [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn21
                 ([]
        )

happyReduce_69 :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce_69 = Int#
-> (HappyAbsSyn Number Int
    -> HappyAbsSyn Number Int -> HappyAbsSyn Number Int)
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_2  Int#
16# HappyAbsSyn Number Int
-> HappyAbsSyn Number Int -> HappyAbsSyn Number Int
forall {t6} {t13} {p} {t6} {t13}.
HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_69
happyReduction_69 :: HappyAbsSyn t6 t13 -> p -> HappyAbsSyn t6 t13
happyReduction_69 HappyAbsSyn t6 t13
happy_x_2
        p
happy_x_1
         =  case HappyAbsSyn t6 t13 -> HappyWrap10
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap10
happyOut10 HappyAbsSyn t6 t13
happy_x_2 of { (HappyWrap10 [Int]
happy_var_2) -> 
        [Int] -> HappyAbsSyn t6 t13
forall t6 t13. [Int] -> HappyAbsSyn t6 t13
happyIn21
                 ([Int]
happy_var_2
        )}

happyTerminalToTok :: Char -> Int#
happyTerminalToTok Char
term = case Char
term of {
        Char
'+' -> Int#
2#;
        Char
'-' -> Int#
3#;
        Char
'.' -> Int#
4#;
        Char
'0' -> Int#
5#;
        Char
'1' -> Int#
6#;
        Char
'2' -> Int#
7#;
        Char
'3' -> Int#
8#;
        Char
'4' -> Int#
9#;
        Char
'5' -> Int#
10#;
        Char
'6' -> Int#
11#;
        Char
'7' -> Int#
12#;
        Char
'8' -> Int#
13#;
        Char
'9' -> Int#
14#;
        Char
'A' -> Int#
15#;
        Char
'B' -> Int#
16#;
        Char
'C' -> Int#
17#;
        Char
'D' -> Int#
18#;
        Char
'E' -> Int#
19#;
        Char
'F' -> Int#
20#;
        Char
'O' -> Int#
21#;
        Char
'P' -> Int#
22#;
        Char
'X' -> Int#
23#;
        Char
_ -> Int#
-1#;
        }
{-# NOINLINE happyTerminalToTok #-}

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

happyNewToken :: Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyNewToken Int#
action Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk = (ZonkAny 0 -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> (Int#
    -> Char -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {t} {a} {t}.
(t -> [a] -> t) -> (Int# -> Char -> String -> t) -> String -> t
happyLex (\ZonkAny 0
tk -> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyDoAction Int#
24# Char
forall a. a
notHappyAtAll Int#
action Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk) (\Int#
i Char
tk -> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyDoAction Int#
i Char
tk Int#
action Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk)

happyReport :: Int#
-> Char
-> [String]
-> (String -> HappyIdentity a)
-> String
-> HappyIdentity a
happyReport Int#
24# Char
tk [String]
explist String -> HappyIdentity a
resume String
tks = String
-> [String] -> (String -> HappyIdentity a) -> HappyIdentity a
forall a.
String
-> [String] -> (String -> HappyIdentity a) -> HappyIdentity a
happyReport' String
tks [String]
explist String -> HappyIdentity a
resume
happyReport Int#
_ Char
tk [String]
explist String -> HappyIdentity a
resume String
tks = String
-> [String] -> (String -> HappyIdentity a) -> HappyIdentity a
forall a.
String
-> [String] -> (String -> HappyIdentity a) -> HappyIdentity a
happyReport' (Char
tkChar -> String -> String
forall a. a -> [a] -> [a]
:String
tks) [String]
explist (\String
tks -> String -> HappyIdentity a
resume (String -> String
forall a. HasCallStack => [a] -> [a]
Happy_Prelude.tail String
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 a. 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 a b.
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 a. 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 a b. m a -> (a -> 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 -> (forall (m :: * -> *) a. Monad m => a -> m a
Happy_Prelude.return) a
a
happyReport' :: () => [(Char)] -> [Happy_Prelude.String] -> ([(Char)] -> (HappyIdentity a)) -> (HappyIdentity a)
happyReport' :: forall a.
String
-> [String] -> (String -> HappyIdentity a) -> HappyIdentity a
happyReport' = (\String
tokens [String]
expected String -> 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.$ String -> a
forall {a}. String -> a
happyError String
tokens)

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

number :: String -> Number
number String
tks = HappyIdentity Number -> Number
forall {a}. HappyIdentity a -> a
happyRunIdentity HappyIdentity Number
happySomeParser where
 happySomeParser :: HappyIdentity Number
happySomeParser = HappyIdentity (HappyAbsSyn Number Int)
-> (HappyAbsSyn Number Int -> HappyIdentity Number)
-> HappyIdentity Number
forall a b.
HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
happyThen (Int# -> String -> HappyIdentity (HappyAbsSyn Number Int)
happyDoParse Int#
0# String
tks) (\HappyAbsSyn Number Int
x -> Number -> HappyIdentity Number
forall a. a -> HappyIdentity a
happyReturn (let {(HappyWrap5 Number
x') = HappyAbsSyn Number Int -> HappyWrap5
forall t6 t13. HappyAbsSyn t6 t13 -> HappyWrap5
happyOut5 HappyAbsSyn Number Int
x} in Number
x'))

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


mkNum :: Radix -> [Int] -> [Int] -> Number
mkNum :: Radix -> [Int] -> [Int] -> Number
mkNum Radix
radix [Int]
coef [Int]
frac =
  Radix -> Rational -> Number
MkNumber Radix
radix (Integer -> Rational
forall a. Num a => Integer -> a
fromInteger (Int -> [Int] -> Integer
toInt Int
base [Int]
coef) Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
+ Int -> [Int] -> Rational
toFrac Int
base [Int]
frac)
  where
    base :: Int
base = Radix -> Int
radixToInt Radix
radix

negNum :: Number -> Number
negNum :: Number -> Number
negNum Number
n = Number
n { numberCoefficient = - numberCoefficient n }

toInt :: Int -> [Int] -> Integer
toInt :: Int -> [Int] -> Integer
toInt Int
base = (Integer -> Int -> Integer) -> Integer -> [Int] -> Integer
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Integer
acc Int
i -> Integer
accInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
*Integer
base' Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) Integer
0 ([Int] -> Integer) -> ([Int] -> [Int]) -> [Int] -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [Int]
forall a. [a] -> [a]
reverse
  where base' :: Integer
base' = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
base

toFrac :: Int -> [Int] -> Rational
toFrac :: Int -> [Int] -> Rational
toFrac Int
base = (Rational -> Int -> Rational) -> Rational -> [Int] -> Rational
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Rational
acc Int
i -> (Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
iRational -> Rational -> Rational
forall a. Num a => a -> a -> a
+Rational
acc)Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/Rational
base') Rational
0
  where base' :: Rational
base' = Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
base

happyError :: String -> a
happyError [] = String -> a
forall a. HasCallStack => String -> a
error String
"Unexpected EOF"
happyError (Char
c:String
_) = String -> a
forall a. HasCallStack => String -> a
error (String
"Unexpected: "String -> String -> String
forall a. [a] -> [a] -> [a]
++[Char
c])
#define HAPPY_COERCE 1
-- $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

happyDoParse :: Int# -> String -> HappyIdentity (HappyAbsSyn Number Int)
happyDoParse Int#
start_state = Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyNewToken Int#
start_state Happy_IntList
forall a. a
notHappyAtAll HappyStk (HappyAbsSyn Number Int)
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyDoAction Int#
i Char
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyFail Int#
i Char
tk Int#
st
    HappyAction
HappyAccept           -> DEBUG_TRACE("accept.\n")
                             Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {p} {p} {a} {b}.
Int# -> p -> Int# -> p -> HappyStk a -> b -> HappyIdentity a
happyAccept Int#
i Char
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#
   -> Char
   -> Int#
   -> Happy_IntList
   -> HappyStk (HappyAbsSyn Number Int)
   -> String
   -> HappyIdentity (HappyAbsSyn Number Int))
happyReduceArr Array
  Int
  (Int#
   -> Char
   -> Int#
   -> Happy_IntList
   -> HappyStk (HappyAbsSyn Number Int)
   -> String
   -> HappyIdentity (HappyAbsSyn Number Int))
-> Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall i e. Ix i => Array i e -> i -> e
Happy_Data_Array.! (Int# -> Int
Happy_GHC_Exts.I# Int#
rule)) Int#
i Char
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyShift Int#
new_state Int#
i Char
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
$cshowsPrec :: Int -> HappyAction -> String -> String
showsPrec :: Int -> HappyAction -> String -> String
$cshow :: HappyAction -> String
show :: HappyAction -> String
$cshowList :: [HappyAction] -> String -> String
showList :: [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
  Int32# -> Int#
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# -> Int32#
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
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 Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk =
     Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
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 Number Int
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happySpecReduce_0 Int#
nt HappyAbsSyn Number Int
fn Int#
j Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk
     = HappyAbsSyn Number Int
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall a b. a -> b -> b
happySeq HappyAbsSyn Number Int
fn (Int#
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyGoto Int#
nt Int#
j Char
tk Int#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) (HappyAbsSyn Number Int
fn HappyAbsSyn Number Int
-> HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number Int)
stk))

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

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

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

happyReduce :: Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> HappyStk (HappyAbsSyn Number Int))
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyReduce Int#
k Int#
nt HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
fn Int#
j Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
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 Number Int)
r = HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
fn HappyStk (HappyAbsSyn Number Int)
stk in -- it doesn't hurt to always seq here...
                Int#
st Int#
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall a. Int# -> a -> a
`happyTcHack` HappyStk (HappyAbsSyn Number Int)
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall a b. a -> b -> b
happyDoSeq HappyStk (HappyAbsSyn Number Int)
r (Int#
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyGoto Int#
nt Int#
j Char
tk Int#
st1 Happy_IntList
sts1 HappyStk (HappyAbsSyn Number Int)
r)

happyMonadReduce :: Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> Char -> HappyIdentity (HappyAbsSyn Number Int))
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyMonadReduce Int#
k Int#
nt HappyStk (HappyAbsSyn Number Int)
-> Char -> HappyIdentity (HappyAbsSyn Number Int)
fn Int#
j Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
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 Number Int)
drop_stk = Int#
-> HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk (HappyAbsSyn Number Int)
stk in
          Int#
j Int#
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall a. Int# -> a -> a
`happyTcHack` HappyIdentity (HappyAbsSyn Number Int)
-> (HappyAbsSyn Number Int
    -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {m :: * -> *} {t} {t} {b}.
Monad m =>
m t -> (t -> t -> m b) -> t -> m b
happyThen1 (HappyStk (HappyAbsSyn Number Int)
-> Char -> HappyIdentity (HappyAbsSyn Number Int)
fn HappyStk (HappyAbsSyn Number Int)
stk Char
tk)
                                     (\HappyAbsSyn Number Int
r -> Int#
-> Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyGoto Int#
nt Int#
j Char
tk Int#
st1 Happy_IntList
sts1 (HappyAbsSyn Number Int
r HappyAbsSyn Number Int
-> HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number Int)
drop_stk))

happyMonad2Reduce :: Int#
-> Int#
-> (HappyStk (HappyAbsSyn Number Int)
    -> t -> HappyIdentity (HappyAbsSyn Number Int))
-> Int#
-> t
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyMonad2Reduce Int#
k Int#
nt HappyStk (HappyAbsSyn Number Int)
-> t -> HappyIdentity (HappyAbsSyn Number Int)
fn Int#
j t
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
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 Number Int)
drop_stk = Int#
-> HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk (HappyAbsSyn Number Int)
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#
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall a. Int# -> a -> a
`happyTcHack` HappyIdentity (HappyAbsSyn Number Int)
-> (HappyAbsSyn Number Int
    -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {m :: * -> *} {t} {t} {b}.
Monad m =>
m t -> (t -> t -> m b) -> t -> m b
happyThen1 (HappyStk (HappyAbsSyn Number Int)
-> t -> HappyIdentity (HappyAbsSyn Number Int)
fn HappyStk (HappyAbsSyn Number Int)
stk t
tk)
                                       (\HappyAbsSyn Number Int
r -> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyNewToken Int#
new_state Happy_IntList
sts1 (HappyAbsSyn Number Int
r HappyAbsSyn Number Int
-> HappyStk (HappyAbsSyn Number Int)
-> HappyStk (HappyAbsSyn Number Int)
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk (HappyAbsSyn Number Int)
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyGoto Int#
nt Int#
j Char
tk Int#
st =
   DEBUG_TRACE(", goto state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
   Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyDoAction Int#
j Char
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyFail ERROR_TOK = happyFixupFailed
happyFail Int#
i         = Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyTryFixup Int#
i Char
tk Int#
action Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk =
  DEBUG_TRACE("entering `error` fixup.\n")
  Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
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 :: Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyFixupFailed Char
tk Int#
st Happy_IntList
sts (HappyAbsSyn Number Int
x `HappyStk` HappyStk (HappyAbsSyn Number Int)
stk) =
  let i :: Int#
i = GET_ERROR_TOKEN(x) in
  DEBUG_TRACE("`error` fixup failed.\n")
  let resume :: String -> HappyIdentity (HappyAbsSyn Number Int)
resume   = Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyResume Int#
i Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk
      expected :: [String]
expected = Int# -> Happy_IntList -> [String]
happyExpectedTokens Int#
st Happy_IntList
sts in
  Int#
-> Char
-> [String]
-> (String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {a}.
Int#
-> Char
-> [String]
-> (String -> HappyIdentity a)
-> String
-> HappyIdentity a
happyReport Int#
i Char
tk [String]
expected String -> HappyIdentity (HappyAbsSyn Number Int)
resume

-- happyResume :: Happy_Int -> Token -> Happy_Int -> _
-- See Note [happyResume]
happyResume :: Int#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyResume Int#
i Char
tk Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
stk = [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
pop_items [] Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
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 Number Int))]
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
pop_items [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames Int#
st Happy_IntList
sts HappyStk (HappyAbsSyn Number Int)
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 Number Int))] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames_new
          then DEBUG_TRACE("no resumption.\n")
               String -> HappyIdentity (HappyAbsSyn Number Int)
forall a. String -> 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#
-> Char
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
discard_input_until_exp Int#
i Char
tk ([(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
forall a. [a] -> [a]
Happy_Prelude.reverse [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames_new)
      | (HappyCons Int#
st1 Happy_IntList
sts1) <- Happy_IntList
sts, HappyAbsSyn Number Int
_ `HappyStk` HappyStk (HappyAbsSyn Number Int)
stk1 <- HappyStk (HappyAbsSyn Number Int)
stk
      = [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
pop_items [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames_new Int#
st1 Happy_IntList
sts1 HappyStk (HappyAbsSyn Number Int)
stk1
      where
        !catch_frames_new :: [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
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 Number Int))] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null (((Happy_IntList, HappyStk (HappyAbsSyn Number Int)) -> Bool)
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
forall a. (a -> Bool) -> [a] -> [a]
Happy_Prelude.filter (\(HappyCons Int#
_ (HappyCons Int#
h Happy_IntList
_),HappyStk (HappyAbsSyn Number Int)
_) -> 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 Number Int))]
catch_frames

    -- See (2) of Note [happyResume]
    discard_input_until_exp :: Int#
-> Char
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
discard_input_until_exp Int#
i Char
tk [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames
      | Happy_Prelude.Just (HappyCons Int#
st (HappyCons Int#
catch_st Happy_IntList
sts), HappyStk (HappyAbsSyn Number Int)
catch_frame) <- Int#
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> Maybe (Happy_IntList, HappyStk (HappyAbsSyn Number Int))
forall {b}.
Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
some_catch_state_shifts Int#
i [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
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#
-> Char
-> Int#
-> Happy_IntList
-> HappyStk (HappyAbsSyn Number Int)
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
happyDoAction Int#
i Char
tk Int#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
catch_st Happy_IntList
sts) HappyStk (HappyAbsSyn Number Int)
catch_frame
      | EQ(i,eof_i) -- is i EOF?
      = DEBUG_TRACE("reached EOF, cannot resume. abort parse :(\n")
        String -> HappyIdentity (HappyAbsSyn Number Int)
forall a. String -> HappyIdentity a
happyAbort
      | Bool
Happy_Prelude.otherwise
      = DEBUG_TRACE("discard token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
        (Char -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> (Int#
    -> Char -> String -> HappyIdentity (HappyAbsSyn Number Int))
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
forall {t} {a} {t}.
(t -> [a] -> t) -> (Int# -> Char -> String -> t) -> String -> t
happyLex (\Char
eof_tk -> Int#
-> Char
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
discard_input_until_exp Int#
eof_i Char
eof_tk [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
catch_frames) -- eof
                 (\Int#
i Char
tk   -> Int#
-> Char
-> [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
-> String
-> HappyIdentity (HappyAbsSyn Number Int)
discard_input_until_exp Int#
i Char
tk [(Happy_IntList, HappyStk (HappyAbsSyn Number Int))]
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. HasCallStack => [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 a b. (a -> b -> b) -> b -> [a] -> b
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
forall a b. 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.