    {-# OPTIONS_GHC -w #-}
    {-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}
    #if __GLASGOW_HASKELL__ >= 710
    {-# OPTIONS_GHC -XPartialTypeSignatures #-}
    #endif
    {-# LANGUAGE Trustworthy #-}

    module Config.NumberParser where

    import Data.List (foldl')
    import Config.Number
    import qualified Data.Array as Happy_Data_Array
    import qualified Data.Bits as Bits
    import qualified GHC.Exts as Happy_GHC_Exts
    import Control.Applicative(Applicative(..))
    import Control.Monad (ap)

    -- parser produced by Happy Version 1.20.1.1

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

    happyExpList :: HappyAddr
    happyExpList :: HappyAddr
    happyExpList = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\xa0\xff\x01\x00\x00\x00\x01\x00\x00\x00\x00\xe0\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\xe0\x1f\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\xfe\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x60\xff\x03\x00\x00\x00\xfc\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\xf8\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x07\x00\x00\x00\xf0\x3f\x00\x00\x00\x80\xff\x01\x00\x00\x00\xfc\x0f\x00\x00\x00\xe0\x7f\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\x00\x00\x00\x00\xfe\x01\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    {-# NOINLINE happyExpListPerState #-}
    happyExpListPerState :: Int -> [String]
    happyExpListPerState Int
    st =
        [String]
    token_strs_expected
      where token_strs :: [String]
    token_strs = [String
    "error",String
    "%dummy",String
    "%start_number",String
    "number",String
    "unsigned_number",String
    "expnum",String
    "hexadecimal",String
    "decimal",String
    "octal",String
    "binary",String
    "hexdigit",String
    "decdigit",String
    "octdigit",String
    "bindigit",String
    "exppart__'E'__",String
    "exppart__'P'__",String
    "fracpart__binary__",String
    "fracpart__decimal__",String
    "fracpart__hexadecimal__",String
    "fracpart__octal__",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"]
            bit_start :: Int
    bit_start = Int
    st Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.* Int
    43
            bit_end :: Int
    bit_end = (Int
    st Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.+ Int
    1) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.* Int
    43
            read_bit :: Int -> Bool
    read_bit = HappyAddr -> Int -> Bool
    readArrayBit HappyAddr
    happyExpList
            bits :: [Bool]
    bits = (Int -> Bool) -> [Int] -> [Bool]
    forall a b. (a -> b) -> [a] -> [b]
    Prelude.map Int -> Bool
    read_bit [Int
    bit_start..Int
    bit_end Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.- Int
    1]
            bits_indexed :: [(Bool, Int)]
    bits_indexed = [Bool] -> [Int] -> [(Bool, Int)]
    forall a b. [a] -> [b] -> [(a, b)]
    Prelude.zip [Bool]
    bits [Int
    0..Int
    42]
            token_strs_expected :: [String]
    token_strs_expected = ((Bool, Int) -> [String]) -> [(Bool, Int)] -> [String]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    Prelude.concatMap (Bool, Int) -> [String]
    f [(Bool, Int)]
    bits_indexed
            f :: (Bool, Int) -> [String]
    f (Bool
    Prelude.False, Int
    _) = []
            f (Bool
    Prelude.True, Int
    nr) = [[String]
    token_strs [String] -> Int -> String
    forall a. HasCallStack => [a] -> Int -> a
    Prelude.!! Int
    nr]

    happyActOffsets :: HappyAddr
    happyActOffsets :: HappyAddr
    happyActOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\x2d\x00\x22\x00\x42\x00\x19\x00\x00\x00\x38\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x6a\x00\x0e\x00\x00\x00\x71\x00\x4c\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x21\x00\xfe\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x8c\x00\x0e\x00\x00\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x0e\x00\x00\x00\x21\x00\x6a\x00\x65\x00\x00\x00\x00\x00"#

    happyGotoOffsets :: HappyAddr
    happyGotoOffsets :: HappyAddr
    happyGotoOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\x63\x00\x00\x00\x76\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\x7f\x00\x83\x00\x87\x00\x00\x00\x6e\x00\x89\x00\x00\x00\x00\x00\x74\x00\x00\x00\x64\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\x6f\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\x85\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x78\x00\x8f\x00\x00\x00\x94\x00\x91\x00\x93\x00\x94\x00\x94\x00\x9c\x00\x00\x00\x7e\x00\x8a\x00\x8e\x00\x00\x00\x00\x00"#

    happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#
    happyAdjustOffset :: Int# -> Int#
    happyAdjustOffset Int#
    off = Int#
    off

    happyDefActions :: HappyAddr
    happyDefActions :: HappyAddr
    happyDefActions = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xc2\xff\xf3\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd4\xff\x00\x00\x00\x00\x00\x00\xf2\xff\xc9\xff\xc1\xff\xdd\xff\xfe\xff\xc0\xff\xfb\xff\x00\x00\xbf\xff\xf5\xff\xed\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\xbc\xff\xf1\xff\xd3\xff\xd2\xff\xd1\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xc5\xff\xef\xff\xcb\xff\xca\xff\xee\xff\xf9\xff\xc4\xff\xf0\xff\xfa\xff\xbb\xff\xf4\xff\xc7\xff\xbe\xff\xc8\xff\xf6\xff\x00\x00\x00\x00\xf7\xff\xf8\xff\xbd\xff\xfc\xff\x00\x00\xba\xff\xc3\xff\xc6\xff"#

    happyCheck :: HappyAddr
    happyCheck :: HappyAddr
    happyCheck = Addr# -> HappyAddr
    HappyA# Addr#
    "\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x01\x00\x02\x00\x02\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x02\x00\x17\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x00\x00\x01\x00\x07\x00\x02\x00\x04\x00\x04\x00\x04\x00\x05\x00\x08\x00\x08\x00\x0f\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0f\x00\x01\x00\x09\x00\x0b\x00\x04\x00\x14\x00\x08\x00\x16\x00\x08\x00\x10\x00\x02\x00\x08\x00\x04\x00\x12\x00\x0c\x00\x06\x00\x08\x00\x0e\x00\x05\x00\x0a\x00\x03\x00\x06\x00\x09\x00\x04\x00\x07\x00\x0a\x00\x05\x00\x08\x00\x03\x00\x09\x00\x09\x00\x04\x00\x07\x00\x04\x00\x0a\x00\x08\x00\x0a\x00\x08\x00\x08\x00\x0d\x00\x03\x00\x04\x00\x05\x00\x15\x00\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#

    happyTable :: HappyAddr
    happyTable :: HappyAddr
    happyTable = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x45\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x49\x00\x03\x00\x18\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x03\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x17\x00\x18\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x18\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x42\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x03\x00\x04\x00\x42\x00\x45\x00\x05\x00\x46\x00\x3b\x00\x3c\x00\x06\x00\x06\x00\x43\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x12\x00\x18\x00\x3f\x00\x1a\x00\x05\x00\x13\x00\x14\x00\x14\x00\x06\x00\x40\x00\x50\x00\x14\x00\x46\x00\x1c\x00\x4c\x00\x38\x00\x06\x00\x15\x00\x2e\x00\x39\x00\x1c\x00\x4f\x00\x2f\x00\x19\x00\x1d\x00\x39\x00\x4e\x00\x06\x00\x4b\x00\x3f\x00\x2f\x00\x4a\x00\x1d\x00\x49\x00\x3c\x00\x06\x00\x3c\x00\x06\x00\x14\x00\x3d\x00\x3f\x00\x3b\x00\x3c\x00\x4e\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    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)
    	]

    happy_n_terms :: Int
    happy_n_terms = Int
    24 :: Prelude.Int
    happy_n_nonterms :: Int
    happy_n_nonterms = Int
    17 :: Prelude.Int

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5} {t12}.
    HappyAbsSyn Number t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_1
    happyReduction_1 :: HappyAbsSyn Number t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_1 HappyAbsSyn Number t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn Number t12 -> Number
    forall t5 t12. HappyAbsSyn t5 t12 -> t5
    happyOut5 HappyAbsSyn Number t12
    happy_x_2 of { Number
    happy_var_2 ->
    	Number -> HappyAbsSyn t5 t12
    forall t5 t12. Number -> HappyAbsSyn t5 t12
    happyIn4
    		 (Number -> Number
    negNum Number
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {t5} {t12}.
    HappyAbsSyn Number t12 -> HappyAbsSyn t5 t12
    happyReduction_2
    happyReduction_2 :: HappyAbsSyn Number t12 -> HappyAbsSyn t5 t12
    happyReduction_2 HappyAbsSyn Number t12
    happy_x_1
    	 =  case HappyAbsSyn Number t12 -> Number
    forall t5 t12. HappyAbsSyn t5 t12 -> t5
    happyOut5 HappyAbsSyn Number t12
    happy_x_1 of { Number
    happy_var_1 ->
    	Number -> HappyAbsSyn t5 t12
    forall t5 t12. Number -> HappyAbsSyn t5 t12
    happyIn4
    		 (Number
    happy_var_1
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12}.
    HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_3
    happyReduction_3 :: HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_3 (HappyAbsSyn Number t12
    happy_x_5 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_4 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_3 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_2 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_1 `HappyStk`
    	HappyStk (HappyAbsSyn Number t12)
    happyRest)
    	 = case HappyAbsSyn Number t12 -> HappyWrap7
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap7
    happyOut7 HappyAbsSyn Number t12
    happy_x_3 of { (HappyWrap7 [Int]
    happy_var_3) ->
    	case HappyAbsSyn Number t12 -> HappyWrap19
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap19
    happyOut19 HappyAbsSyn Number t12
    happy_x_4 of { (HappyWrap19 [Int]
    happy_var_4) ->
    	case HappyAbsSyn Number t12 -> HappyWrap16
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap16
    happyOut16 HappyAbsSyn Number t12
    happy_x_5 of { (HappyWrap16 Integer
    happy_var_5) ->
    	Number -> HappyAbsSyn Number t12
    forall t5 t12. t5 -> HappyAbsSyn t5 t12
    happyIn5
    		 (Radix -> [Int] -> [Int] -> Number
    mkNum (Integer -> Radix
    Radix16 Integer
    happy_var_5) [Int]
    happy_var_3 [Int]
    happy_var_4
    	) HappyAbsSyn Number t12
    -> HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk (HappyAbsSyn Number t12)
    happyRest}}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12} {t5} {t12} {t12}.
    HappyAbsSyn t5 t12
    -> HappyAbsSyn t5 t12
    -> HappyAbsSyn t5 t12
    -> HappyAbsSyn Number t12
    happyReduction_4
    happyReduction_4 :: HappyAbsSyn t5 t12
    -> HappyAbsSyn t5 t12
    -> HappyAbsSyn t5 t12
    -> HappyAbsSyn Number t12
    happyReduction_4 HappyAbsSyn t5 t12
    happy_x_3
    	HappyAbsSyn t5 t12
    happy_x_2
    	HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap8 [Int]
    happy_var_1) ->
    	case HappyAbsSyn t5 t12 -> HappyWrap18
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap18
    happyOut18 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap18 [Int]
    happy_var_2) ->
    	case HappyAbsSyn t5 t12 -> HappyWrap15
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap15
    happyOut15 HappyAbsSyn t5 t12
    happy_x_3 of { (HappyWrap15 Integer
    happy_var_3) ->
    	Number -> HappyAbsSyn Number t12
    forall t5 t12. t5 -> HappyAbsSyn t5 t12
    happyIn5
    		 (Radix -> [Int] -> [Int] -> Number
    mkNum (Integer -> Radix
    Radix10 Integer
    happy_var_3) [Int]
    happy_var_1 [Int]
    happy_var_2
    	)}}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12}.
    HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_5
    happyReduction_5 :: HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_5 (HappyAbsSyn Number t12
    happy_x_4 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_3 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_2 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_1 `HappyStk`
    	HappyStk (HappyAbsSyn Number t12)
    happyRest)
    	 = case HappyAbsSyn Number t12 -> HappyWrap9
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap9
    happyOut9 HappyAbsSyn Number t12
    happy_x_3 of { (HappyWrap9 [Int]
    happy_var_3) ->
    	case HappyAbsSyn Number t12 -> HappyWrap20
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap20
    happyOut20 HappyAbsSyn Number t12
    happy_x_4 of { (HappyWrap20 [Int]
    happy_var_4) ->
    	Number -> HappyAbsSyn Number t12
    forall t5 t12. t5 -> HappyAbsSyn t5 t12
    happyIn5
    		 (Radix -> [Int] -> [Int] -> Number
    mkNum Radix
    Radix8 [Int]
    happy_var_3 [Int]
    happy_var_4
    	) HappyAbsSyn Number t12
    -> HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk (HappyAbsSyn Number t12)
    happyRest}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12}.
    HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_6
    happyReduction_6 :: HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    happyReduction_6 (HappyAbsSyn Number t12
    happy_x_4 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_3 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_2 `HappyStk`
    	HappyAbsSyn Number t12
    happy_x_1 `HappyStk`
    	HappyStk (HappyAbsSyn Number t12)
    happyRest)
    	 = case HappyAbsSyn Number t12 -> HappyWrap10
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap10
    happyOut10 HappyAbsSyn Number t12
    happy_x_3 of { (HappyWrap10 [Int]
    happy_var_3) ->
    	case HappyAbsSyn Number t12 -> HappyWrap17
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap17
    happyOut17 HappyAbsSyn Number t12
    happy_x_4 of { (HappyWrap17 [Int]
    happy_var_4) ->
    	Number -> HappyAbsSyn Number t12
    forall t5 t12. t5 -> HappyAbsSyn t5 t12
    happyIn5
    		 (Radix -> [Int] -> [Int] -> Number
    mkNum Radix
    Radix2 [Int]
    happy_var_3 [Int]
    happy_var_4
    	) HappyAbsSyn Number t12
    -> HappyStk (HappyAbsSyn Number t12)
    -> HappyStk (HappyAbsSyn Number t12)
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk (HappyAbsSyn Number t12)
    happyRest}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_7
    happyReduction_7 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_7 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap8 [Int]
    happy_var_2) ->
    	Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn6
    		 (Int -> [Int] -> Integer
    toInt Int
    10 [Int]
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_8
    happyReduction_8 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_8 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap8 [Int]
    happy_var_2) ->
    	Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn6
    		 (- Int -> [Int] -> Integer
    toInt Int
    10 [Int]
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_9
    happyReduction_9 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_9 HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap8 [Int]
    happy_var_1) ->
    	Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn6
    		 (Int -> [Int] -> Integer
    toInt Int
    10 [Int]
    happy_var_1
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_10
    happyReduction_10 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_10 HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap11
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap11
    happyOut11 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap11 Int
    happy_var_1) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn7
    		 ([Int
    happy_var_1]
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_11
    happyReduction_11 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_11 HappyAbsSyn t5 t12
    happy_x_2
    	HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap7
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap7
    happyOut7 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap7 [Int]
    happy_var_1) ->
    	case HappyAbsSyn t5 t12 -> HappyWrap11
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap11
    happyOut11 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap11 Int
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn7
    		 (Int
    happy_var_2 Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : [Int]
    happy_var_1
    	)}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t5} {t12}. HappyAbsSyn t5 Int -> HappyAbsSyn t5 t12
    happyReduction_12
    happyReduction_12 :: HappyAbsSyn t5 Int -> HappyAbsSyn t5 t12
    happyReduction_12 HappyAbsSyn t5 Int
    happy_x_1
    	 =  case HappyAbsSyn t5 Int -> Int
    forall t5 t12. HappyAbsSyn t5 t12 -> t12
    happyOut12 HappyAbsSyn t5 Int
    happy_x_1 of { Int
    happy_var_1 ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn8
    		 ([Int
    happy_var_1]
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 Int -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_13
    happyReduction_13 :: HappyAbsSyn t5 Int -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_13 HappyAbsSyn t5 Int
    happy_x_2
    	HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap8 [Int]
    happy_var_1) ->
    	case HappyAbsSyn t5 Int -> Int
    forall t5 t12. HappyAbsSyn t5 t12 -> t12
    happyOut12 HappyAbsSyn t5 Int
    happy_x_2 of { Int
    happy_var_2 ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn8
    		 (Int
    happy_var_2 Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : [Int]
    happy_var_1
    	)}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_14
    happyReduction_14 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_14 HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap13
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap13
    happyOut13 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap13 Int
    happy_var_1) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn9
    		 ([Int
    happy_var_1]
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_15
    happyReduction_15 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_15 HappyAbsSyn t5 t12
    happy_x_2
    	HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap9
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap9
    happyOut9 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap9 [Int]
    happy_var_1) ->
    	case HappyAbsSyn t5 t12 -> HappyWrap13
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap13
    happyOut13 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap13 Int
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn9
    		 (Int
    happy_var_2 Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : [Int]
    happy_var_1
    	)}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_16
    happyReduction_16 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_16 HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap14
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap14
    happyOut14 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap14 Int
    happy_var_1) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn10
    		 ([Int
    happy_var_1]
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {t5} {t12} {t5} {t12}.
    HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_17
    happyReduction_17 :: HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12 -> HappyAbsSyn t5 t12
    happyReduction_17 HappyAbsSyn t5 t12
    happy_x_2
    	HappyAbsSyn t5 t12
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap10
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap10
    happyOut10 HappyAbsSyn t5 t12
    happy_x_1 of { (HappyWrap10 [Int]
    happy_var_1) ->
    	case HappyAbsSyn t5 t12 -> HappyWrap14
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap14
    happyOut14 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap14 Int
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn10
    		 (Int
    happy_var_2 Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : [Int]
    happy_var_1
    	)}}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_18
    happyReduction_18 :: p -> HappyAbsSyn t5 t12
    happyReduction_18 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_19
    happyReduction_19 :: p -> HappyAbsSyn t5 t12
    happyReduction_19 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    1
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_20
    happyReduction_20 :: p -> HappyAbsSyn t5 t12
    happyReduction_20 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    2
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_21
    happyReduction_21 :: p -> HappyAbsSyn t5 t12
    happyReduction_21 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    3
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_22
    happyReduction_22 :: p -> HappyAbsSyn t5 t12
    happyReduction_22 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    4
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_23
    happyReduction_23 :: p -> HappyAbsSyn t5 t12
    happyReduction_23 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    5
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_24
    happyReduction_24 :: p -> HappyAbsSyn t5 t12
    happyReduction_24 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    6
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_25
    happyReduction_25 :: p -> HappyAbsSyn t5 t12
    happyReduction_25 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    7
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_26
    happyReduction_26 :: p -> HappyAbsSyn t5 t12
    happyReduction_26 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    8
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_27
    happyReduction_27 :: p -> HappyAbsSyn t5 t12
    happyReduction_27 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    9
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_28
    happyReduction_28 :: p -> HappyAbsSyn t5 t12
    happyReduction_28 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    10
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_29
    happyReduction_29 :: p -> HappyAbsSyn t5 t12
    happyReduction_29 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    11
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_30
    happyReduction_30 :: p -> HappyAbsSyn t5 t12
    happyReduction_30 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    12
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_31
    happyReduction_31 :: p -> HappyAbsSyn t5 t12
    happyReduction_31 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    13
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_32
    happyReduction_32 :: p -> HappyAbsSyn t5 t12
    happyReduction_32 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    14
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_33
    happyReduction_33 :: p -> HappyAbsSyn t5 t12
    happyReduction_33 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn11
    		 (Int
    15
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_34
    happyReduction_34 :: p -> HappyAbsSyn t5 t12
    happyReduction_34 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_35
    happyReduction_35 :: p -> HappyAbsSyn t5 t12
    happyReduction_35 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    1
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_36
    happyReduction_36 :: p -> HappyAbsSyn t5 t12
    happyReduction_36 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    2
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_37
    happyReduction_37 :: p -> HappyAbsSyn t5 t12
    happyReduction_37 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    3
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_38
    happyReduction_38 :: p -> HappyAbsSyn t5 t12
    happyReduction_38 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    4
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_39
    happyReduction_39 :: p -> HappyAbsSyn t5 t12
    happyReduction_39 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    5
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_40
    happyReduction_40 :: p -> HappyAbsSyn t5 t12
    happyReduction_40 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    6
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_41
    happyReduction_41 :: p -> HappyAbsSyn t5 t12
    happyReduction_41 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    7
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_42
    happyReduction_42 :: p -> HappyAbsSyn t5 t12
    happyReduction_42 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    8
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t12} {p} {t5}. Num t12 => p -> HappyAbsSyn t5 t12
    happyReduction_43
    happyReduction_43 :: p -> HappyAbsSyn t5 t12
    happyReduction_43 p
    happy_x_1
    	 =  t12 -> HappyAbsSyn t5 t12
    forall t12 t5. t12 -> HappyAbsSyn t5 t12
    happyIn12
    		 (t12
    9
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_44
    happyReduction_44 :: p -> HappyAbsSyn t5 t12
    happyReduction_44 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_45
    happyReduction_45 :: p -> HappyAbsSyn t5 t12
    happyReduction_45 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    1
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_46
    happyReduction_46 :: p -> HappyAbsSyn t5 t12
    happyReduction_46 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    2
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_47
    happyReduction_47 :: p -> HappyAbsSyn t5 t12
    happyReduction_47 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    3
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_48
    happyReduction_48 :: p -> HappyAbsSyn t5 t12
    happyReduction_48 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    4
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_49
    happyReduction_49 :: p -> HappyAbsSyn t5 t12
    happyReduction_49 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    5
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_50
    happyReduction_50 :: p -> HappyAbsSyn t5 t12
    happyReduction_50 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    6
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_51
    happyReduction_51 :: p -> HappyAbsSyn t5 t12
    happyReduction_51 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn13
    		 (Int
    7
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_52
    happyReduction_52 :: p -> HappyAbsSyn t5 t12
    happyReduction_52 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn14
    		 (Int
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_53
    happyReduction_53 :: p -> HappyAbsSyn t5 t12
    happyReduction_53 p
    happy_x_1
    	 =  Int -> HappyAbsSyn t5 t12
    forall t5 t12. Int -> HappyAbsSyn t5 t12
    happyIn14
    		 (Int
    1
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_54
    happyReduction_54 :: HappyAbsSyn t5 t12
    happyReduction_54  =  Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn15
    		 (Integer
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_55
    happyReduction_55 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_55 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap6
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap6
    happyOut6 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap6 Integer
    happy_var_2) ->
    	Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn15
    		 (Integer
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_56
    happyReduction_56 :: HappyAbsSyn t5 t12
    happyReduction_56  =  Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn16
    		 (Integer
    0
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_57
    happyReduction_57 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_57 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap6
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap6
    happyOut6 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap6 Integer
    happy_var_2) ->
    	Integer -> HappyAbsSyn t5 t12
    forall t5 t12. Integer -> HappyAbsSyn t5 t12
    happyIn16
    		 (Integer
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_58
    happyReduction_58 :: HappyAbsSyn t5 t12
    happyReduction_58  =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn17
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_59
    happyReduction_59 :: p -> HappyAbsSyn t5 t12
    happyReduction_59 p
    happy_x_1
    	 =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn17
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_60
    happyReduction_60 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_60 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap10
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap10
    happyOut10 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap10 [Int]
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn17
    		 ([Int]
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_61
    happyReduction_61 :: HappyAbsSyn t5 t12
    happyReduction_61  =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn18
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_62
    happyReduction_62 :: p -> HappyAbsSyn t5 t12
    happyReduction_62 p
    happy_x_1
    	 =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn18
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_63
    happyReduction_63 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_63 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap8
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap8
    happyOut8 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap8 [Int]
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn18
    		 ([Int]
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_64
    happyReduction_64 :: HappyAbsSyn t5 t12
    happyReduction_64  =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn19
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_65
    happyReduction_65 :: p -> HappyAbsSyn t5 t12
    happyReduction_65 p
    happy_x_1
    	 =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn19
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_66
    happyReduction_66 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_66 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap7
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap7
    happyOut7 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap7 [Int]
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn19
    		 ([Int]
    happy_var_2
    	)}

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12}. HappyAbsSyn t5 t12
    happyReduction_67
    happyReduction_67 :: HappyAbsSyn t5 t12
    happyReduction_67  =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn20
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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} {t5} {t12}. p -> HappyAbsSyn t5 t12
    happyReduction_68
    happyReduction_68 :: p -> HappyAbsSyn t5 t12
    happyReduction_68 p
    happy_x_1
    	 =  [Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn20
    		 ([]
    	)

    #if __GLASGOW_HASKELL__ >= 710
    #endif
    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 {t5} {t12} {p} {t5} {t12}.
    HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_69
    happyReduction_69 :: HappyAbsSyn t5 t12 -> p -> HappyAbsSyn t5 t12
    happyReduction_69 HappyAbsSyn t5 t12
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn t5 t12 -> HappyWrap9
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap9
    happyOut9 HappyAbsSyn t5 t12
    happy_x_2 of { (HappyWrap9 [Int]
    happy_var_2) ->
    	[Int] -> HappyAbsSyn t5 t12
    forall t5 t12. [Int] -> HappyAbsSyn t5 t12
    happyIn20
    		 ([Int]
    happy_var_2
    	)}

    happyNewToken :: Int#
    -> Happy_IntList
    -> HappyStk (HappyAbsSyn Number Int)
    -> String
    -> HappyIdentity (HappyAbsSyn Number Int)
    happyNewToken Int#
    action Happy_IntList
    sts HappyStk (HappyAbsSyn Number Int)
    stk [] =
    	Int#
    -> Char
    -> Int#
    -> Happy_IntList
    -> HappyStk (HappyAbsSyn Number Int)
    -> String
    -> HappyIdentity (HappyAbsSyn Number Int)
    happyDoAction Int#
    23# Char
    forall a. a
    notHappyAtAll Int#
    action Happy_IntList
    sts HappyStk (HappyAbsSyn Number Int)
    stk []

    happyNewToken Int#
    action Happy_IntList
    sts HappyStk (HappyAbsSyn Number Int)
    stk (Char
    tk:String
    tks) =
    	let cont :: Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    i = 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 String
    tks in
    	case Char
    tk of {
    	Char
    '+' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    1#;
    	Char
    '-' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    2#;
    	Char
    '.' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    3#;
    	Char
    '0' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    4#;
    	Char
    '1' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    5#;
    	Char
    '2' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    6#;
    	Char
    '3' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    7#;
    	Char
    '4' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    8#;
    	Char
    '5' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    9#;
    	Char
    '6' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    10#;
    	Char
    '7' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    11#;
    	Char
    '8' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    12#;
    	Char
    '9' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    13#;
    	Char
    'A' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    14#;
    	Char
    'B' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    15#;
    	Char
    'C' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    16#;
    	Char
    'D' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    17#;
    	Char
    'E' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    18#;
    	Char
    'F' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    19#;
    	Char
    'O' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    20#;
    	Char
    'P' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    21#;
    	Char
    'X' -> Int# -> HappyIdentity (HappyAbsSyn Number Int)
    cont Int#
    22#;
    	Char
    _ -> (String, [String]) -> HappyIdentity (HappyAbsSyn Number Int)
    forall a. (String, [String]) -> HappyIdentity a
    happyError' ((Char
    tkChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    tks), [])
    	}

    happyError_ :: [String] -> Int# -> Char -> String -> HappyIdentity a
    happyError_ [String]
    explist Int#
    23# Char
    tk String
    tks = (String, [String]) -> HappyIdentity a
    forall a. (String, [String]) -> HappyIdentity a
    happyError' (String
    tks, [String]
    explist)
    happyError_ [String]
    explist Int#
    _ Char
    tk String
    tks = (String, [String]) -> HappyIdentity a
    forall a. (String, [String]) -> HappyIdentity a
    happyError' ((Char
    tkChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    tks), [String]
    explist)

    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 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 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
    (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
    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
    (Prelude.>>=) m t
    m (\t
    a -> t -> t -> m b
    k t
    a t
    tks)
    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
    Prelude.return) a
    a
    happyError' :: () => ([(Char)], [Prelude.String]) -> HappyIdentity a
    happyError' :: forall a. (String, [String]) -> HappyIdentity a
    happyError' = a -> HappyIdentity a
    forall a. a -> HappyIdentity a
    HappyIdentity (a -> HappyIdentity a)
    -> ((String, [String]) -> a)
    -> (String, [String])
    -> HappyIdentity a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    Prelude.. (\(String
    tokens, [String]
    _) -> String -> a
    forall {a}. String -> a
    happyError String
    tokens)
    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)
    happyParse Int#
    0# String
    tks) (\HappyAbsSyn Number Int
    x -> Number -> HappyIdentity Number
    forall a. a -> HappyIdentity a
    happyReturn (let {(HappyWrap4 Number
    x') = HappyAbsSyn Number Int -> HappyWrap4
    forall t5 t12. HappyAbsSyn t5 t12 -> HappyWrap4
    happyOut4 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])
    {-# LINE 1 "templates/GenericTemplate.hs" #-}
    -- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $

    -- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
    #if __GLASGOW_HASKELL__ > 706
    #define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Prelude.Bool)
    #define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Prelude.Bool)
    #define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Prelude.Bool)
    #else
    #define LT(n,m) (n Happy_GHC_Exts.<# m)
    #define GTE(n,m) (n Happy_GHC_Exts.>=# m)
    #define EQ(n,m) (n Happy_GHC_Exts.==# m)
    #endif

    data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList

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

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

    happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll

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

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

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

    happyDoAction i tk st
            = {- nothing -}
              case action of
                    0#           -> {- nothing -}
                                         happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Prelude.Int)) i tk st
                    -1#          -> {- nothing -}
                                         happyAccept i tk st
                    n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
                                                       (happyReduceArr Happy_Data_Array.! rule) i tk st
                                                       where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
                    n                 -> {- nothing -}
                                         happyShift new_state i tk st
                                         where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
       where off    = happyAdjustOffset (indexShortOffAddr happyActOffsets st)
             off_i  = (off Happy_GHC_Exts.+# i)
             check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
                      then EQ(indexShortOffAddr happyCheck off_i, i)
                      else Prelude.False
             action
              | check     = indexShortOffAddr happyTable off_i
              | Prelude.otherwise = indexShortOffAddr happyDefActions st

    indexShortOffAddr (HappyA# arr) off =
            Happy_GHC_Exts.narrow16Int# i
      where
            i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
            high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
            low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
            off' = off Happy_GHC_Exts.*# 2#

    {-# INLINE happyLt #-}
    happyLt x y = LT(x,y)

    readArrayBit arr bit =
        Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `Prelude.mod` 16)
      where unbox_int (Happy_GHC_Exts.I# x) = x

    data HappyAddr = HappyA# Happy_GHC_Exts.Addr#

    -----------------------------------------------------------------------------
    -- HappyState data type (not arrays)

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

    happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
         let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
    --     trace "shifting the error token" $
         happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)

    happyShift new_state i tk st sts stk =
         happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)

    -- happyReduce is specialised for the common cases.

    happySpecReduce_0 i fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happySpecReduce_0 nt fn j tk st@((action)) sts stk
         = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)

    happySpecReduce_1 i fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
         = let r = fn v1 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happySpecReduce_2 i fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
         = let r = fn v1 v2 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happySpecReduce_3 i fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
         = let r = fn v1 v2 v3 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happyReduce k i fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happyReduce k nt fn j tk st sts stk
         = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
             sts1@((HappyCons (st1@(action)) (_))) ->
                    let r = fn stk in  -- it doesn't hurt to always seq here...
                    happyDoSeq r (happyGoto nt j tk st1 sts1 r)

    happyMonadReduce k nt fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happyMonadReduce k nt fn j tk st sts stk =
          case happyDrop k (HappyCons (st) (sts)) of
            sts1@((HappyCons (st1@(action)) (_))) ->
              let drop_stk = happyDropStk k stk in
              happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))

    happyMonad2Reduce k nt fn 0# tk st sts stk
         = happyFail [] 0# tk st sts stk
    happyMonad2Reduce k nt fn j tk st sts stk =
          case happyDrop k (HappyCons (st) (sts)) of
            sts1@((HappyCons (st1@(action)) (_))) ->
             let drop_stk = happyDropStk k stk

                 off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)
                 off_i = (off Happy_GHC_Exts.+# nt)
                 new_state = indexShortOffAddr happyTable off_i

              in
              happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))

    happyDrop 0# l = l
    happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t

    happyDropStk 0# l = l
    happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs

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

    happyGoto nt j tk st =
       {- nothing -}
       happyDoAction j tk new_state
       where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)
             off_i = (off Happy_GHC_Exts.+# nt)
             new_state = indexShortOffAddr happyTable off_i

    -----------------------------------------------------------------------------
    -- Error recovery (ERROR_TOK is the error token)

    -- parse error if we are in recovery and we fail again
    happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =
         let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
    --      trace "failing" $
            happyError_ explist i tk

    {-  We don't need state discarding for our restricted implementation of
        "error".  In fact, it can cause some bogus parses, so I've disabled it
        for now --SDM

    -- discard a state
    happyFail  ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts)
                                                    (saved_tok `HappyStk` _ `HappyStk` stk) =
    --      trace ("discarding state, depth " ++ show (length stk))  $
            DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))
    -}

    -- Enter error recovery: generate an error token,
    --                       save the old token and carry on.
    happyFail explist i tk (action) sts stk =
    --      trace "entering error recovery" $
            happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)

    -- Internal happy errors:

    notHappyAtAll :: a
    notHappyAtAll = Prelude.error "Internal Happy error\n"

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

    happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
    happyTcHack x y = y
    {-# INLINE happyTcHack #-}

    -----------------------------------------------------------------------------
    -- Seq-ing.  If the --strict flag is given, then Happy emits
    --      happySeq = happyDoSeq
    -- otherwise it emits
    --      happySeq = happyDontSeq

    happyDoSeq, happyDontSeq :: a -> b -> b
    happyDoSeq   a b = a `Prelude.seq` b
    happyDontSeq a b = b

    -----------------------------------------------------------------------------
    -- Don't inline any functions from the template.  GHC has a nasty habit
    -- of deciding to inline happyGoto everywhere, which increases the size of
    -- the generated parser quite a bit.

    {-# NOINLINE happyDoAction #-}
    {-# NOINLINE happyTable #-}
    {-# NOINLINE happyCheck #-}
    {-# NOINLINE happyActOffsets #-}
    {-# NOINLINE happyGotoOffsets #-}
    {-# NOINLINE happyDefActions #-}

    {-# NOINLINE happyShift #-}
    {-# NOINLINE happySpecReduce_0 #-}
    {-# NOINLINE happySpecReduce_1 #-}
    {-# NOINLINE happySpecReduce_2 #-}
    {-# NOINLINE happySpecReduce_3 #-}
    {-# NOINLINE happyReduce #-}
    {-# NOINLINE happyMonadReduce #-}
    {-# NOINLINE happyGoto #-}
    {-# NOINLINE happyFail #-}

    -- end of Happy Template.