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

    module Config.Parser (parseValue) where

    import Config.Value   (Section(..), Value(..), Atom(..))
    import Config.Tokens  (Located(..), Token, Position)
    import qualified Config.Tokens as T
    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  = HappyAbsSyn HappyAny
    #if __GLASGOW_HASKELL__ >= 607
    type HappyAny = Happy_GHC_Exts.Any
    #else
    type HappyAny = forall a . a
    #endif
    newtype HappyWrap4 = HappyWrap4 (Value Position)
    happyIn4 :: (Value Position) -> (HappyAbsSyn )
    happyIn4 :: Value Position -> HappyAbsSyn
    happyIn4 Value Position
    x = HappyWrap4 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Value Position -> HappyWrap4
    HappyWrap4 Value Position
    x)
    {-# INLINE happyIn4 #-}
    happyOut4 :: (HappyAbsSyn ) -> HappyWrap4
    happyOut4 :: HappyAbsSyn -> HappyWrap4
    happyOut4 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap4
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut4 #-}
    newtype HappyWrap5 = HappyWrap5 (Value Position)
    happyIn5 :: (Value Position) -> (HappyAbsSyn )
    happyIn5 :: Value Position -> HappyAbsSyn
    happyIn5 Value Position
    x = HappyWrap5 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Value Position -> HappyWrap5
    HappyWrap5 Value Position
    x)
    {-# INLINE happyIn5 #-}
    happyOut5 :: (HappyAbsSyn ) -> HappyWrap5
    happyOut5 :: HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap5
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut5 #-}
    newtype HappyWrap6 = HappyWrap6 (Value Position)
    happyIn6 :: (Value Position) -> (HappyAbsSyn )
    happyIn6 :: Value Position -> HappyAbsSyn
    happyIn6 Value Position
    x = HappyWrap6 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Value Position -> HappyWrap6
    HappyWrap6 Value Position
    x)
    {-# INLINE happyIn6 #-}
    happyOut6 :: (HappyAbsSyn ) -> HappyWrap6
    happyOut6 :: HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap6
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut6 #-}
    newtype HappyWrap7 = HappyWrap7 (())
    happyIn7 :: (()) -> (HappyAbsSyn )
    happyIn7 :: () -> HappyAbsSyn
    happyIn7 ()
    x = HappyWrap7 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap7
    HappyWrap7 ()
    x)
    {-# INLINE happyIn7 #-}
    happyOut7 :: (HappyAbsSyn ) -> HappyWrap7
    happyOut7 :: HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap7
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut7 #-}
    newtype HappyWrap8 = HappyWrap8 ([Section Position])
    happyIn8 :: ([Section Position]) -> (HappyAbsSyn )
    happyIn8 :: [Section Position] -> HappyAbsSyn
    happyIn8 [Section Position]
    x = HappyWrap8 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Section Position] -> HappyWrap8
    HappyWrap8 [Section Position]
    x)
    {-# INLINE happyIn8 #-}
    happyOut8 :: (HappyAbsSyn ) -> HappyWrap8
    happyOut8 :: HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap8
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut8 #-}
    newtype HappyWrap9 = HappyWrap9 ([Section Position])
    happyIn9 :: ([Section Position]) -> (HappyAbsSyn )
    happyIn9 :: [Section Position] -> HappyAbsSyn
    happyIn9 [Section Position]
    x = HappyWrap9 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Section Position] -> HappyWrap9
    HappyWrap9 [Section Position]
    x)
    {-# INLINE happyIn9 #-}
    happyOut9 :: (HappyAbsSyn ) -> HappyWrap9
    happyOut9 :: HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap9
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut9 #-}
    newtype HappyWrap10 = HappyWrap10 ([Section Position])
    happyIn10 :: ([Section Position]) -> (HappyAbsSyn )
    happyIn10 :: [Section Position] -> HappyAbsSyn
    happyIn10 [Section Position]
    x = HappyWrap10 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Section Position] -> HappyWrap10
    HappyWrap10 [Section Position]
    x)
    {-# INLINE happyIn10 #-}
    happyOut10 :: (HappyAbsSyn ) -> HappyWrap10
    happyOut10 :: HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap10
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut10 #-}
    newtype HappyWrap11 = HappyWrap11 (Section Position)
    happyIn11 :: (Section Position) -> (HappyAbsSyn )
    happyIn11 :: Section Position -> HappyAbsSyn
    happyIn11 Section Position
    x = HappyWrap11 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Section Position -> HappyWrap11
    HappyWrap11 Section Position
    x)
    {-# INLINE happyIn11 #-}
    happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
    happyOut11 :: HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap11
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut11 #-}
    newtype HappyWrap12 = HappyWrap12 ([Value Position])
    happyIn12 :: ([Value Position]) -> (HappyAbsSyn )
    happyIn12 :: [Value Position] -> HappyAbsSyn
    happyIn12 [Value Position]
    x = HappyWrap12 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Value Position] -> HappyWrap12
    HappyWrap12 [Value Position]
    x)
    {-# INLINE happyIn12 #-}
    happyOut12 :: (HappyAbsSyn ) -> HappyWrap12
    happyOut12 :: HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap12
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut12 #-}
    newtype HappyWrap13 = HappyWrap13 ([Value Position])
    happyIn13 :: ([Value Position]) -> (HappyAbsSyn )
    happyIn13 :: [Value Position] -> HappyAbsSyn
    happyIn13 [Value Position]
    x = HappyWrap13 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Value Position] -> HappyWrap13
    HappyWrap13 [Value Position]
    x)
    {-# INLINE happyIn13 #-}
    happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
    happyOut13 :: HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap13
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut13 #-}
    newtype HappyWrap14 = HappyWrap14 ([Value Position])
    happyIn14 :: ([Value Position]) -> (HappyAbsSyn )
    happyIn14 :: [Value Position] -> HappyAbsSyn
    happyIn14 [Value Position]
    x = HappyWrap14 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Value Position] -> HappyWrap14
    HappyWrap14 [Value Position]
    x)
    {-# INLINE happyIn14 #-}
    happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
    happyOut14 :: HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap14
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut14 #-}
    newtype HappyWrap15 = HappyWrap15 ([Value Position])
    happyIn15 :: ([Value Position]) -> (HappyAbsSyn )
    happyIn15 :: [Value Position] -> HappyAbsSyn
    happyIn15 [Value Position]
    x = HappyWrap15 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Value Position] -> HappyWrap15
    HappyWrap15 [Value Position]
    x)
    {-# INLINE happyIn15 #-}
    happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
    happyOut15 :: HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap15
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut15 #-}
    newtype HappyWrap16 = HappyWrap16 ([Value Position])
    happyIn16 :: ([Value Position]) -> (HappyAbsSyn )
    happyIn16 :: [Value Position] -> HappyAbsSyn
    happyIn16 [Value Position]
    x = HappyWrap16 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Value Position] -> HappyWrap16
    HappyWrap16 [Value Position]
    x)
    {-# INLINE happyIn16 #-}
    happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
    happyOut16 :: HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap16
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut16 #-}
    happyInTok :: (Located Token) -> (HappyAbsSyn )
    happyInTok :: Located Token -> HappyAbsSyn
    happyInTok Located Token
    x = Located Token -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# Located Token
    x
    {-# INLINE happyInTok #-}
    happyOutTok :: (HappyAbsSyn ) -> (Located Token)
    happyOutTok :: HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    x = HappyAbsSyn -> Located Token
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOutTok #-}

    happyExpList :: HappyAddr
    happyExpList :: HappyAddr
    happyExpList = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\xff\x04\x00\x00\xff\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\xff\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x04\x00\x00\xff\x04\x00\x00\xff\x04\x00\x00\x8e\x04\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x8e\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x04\x00\x00\xff\x04\x00\x00\xff\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    {-# NOINLINE happyExpListPerState #-}
    happyExpListPerState :: Int -> [a]
    happyExpListPerState Int
    st =
        [a]
    token_strs_expected
      where token_strs :: [a]
    token_strs = [a
    "error",a
    "%dummy",a
    "%start_config",a
    "config",a
    "value",a
    "simple",a
    "term",a
    "sections",a
    "inlinesections",a
    "inlinesections1",a
    "section",a
    "inlinelist",a
    "inlinelist1",a
    "list__'*'__",a
    "list__'+'__",a
    "list__'-'__",a
    "SECTION",a
    "STRING",a
    "ATOM",a
    "NUMBER",a
    "'*'",a
    "'+'",a
    "'-'",a
    "'['",a
    "','",a
    "']'",a
    "'{'",a
    "'}'",a
    "SEP",a
    "END",a
    "EOF",a
    "%eof"]
            bit_start :: Int
    bit_start = Int
    st Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.* Int
    32
            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
    32
            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
    31]
            token_strs_expected :: [a]
    token_strs_expected = ((Bool, Int) -> [a]) -> [(Bool, Int)] -> [a]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    Prelude.concatMap (Bool, Int) -> [a]
    f [(Bool, Int)]
    bits_indexed
            f :: (Bool, Int) -> [a]
    f (Bool
    Prelude.False, Int
    _) = []
            f (Bool
    Prelude.True, Int
    nr) = [[a]
    token_strs [a] -> Int -> a
    forall a. HasCallStack => [a] -> Int -> a
    Prelude.!! Int
    nr]

    happyActOffsets :: HappyAddr
    happyActOffsets :: HappyAddr
    happyActOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\x0d\x00\x0d\x00\xf2\xff\x00\x00\x40\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x0d\x00\x1b\x00\x19\x00\x0b\x00\x3a\x00\x1c\x00\x00\x00\x00\x00\x36\x00\x1f\x00\x00\x00\x42\x00\x00\x00\x44\x00\x00\x00\x46\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0d\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyGotoOffsets :: HappyAddr
    happyGotoOffsets :: HappyAddr
    happyGotoOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\x2b\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x20\x00\x15\x00\x01\x00\x02\x00\x45\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x37\x00\x3b\x00\x00\x00\x00\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\xf9\xff\x00\x00\xee\xff\x00\x00\xf7\xff\xf6\xff\xf8\xff\x00\x00\x00\x00\x00\x00\xe6\xff\xec\xff\x00\x00\x00\x00\xeb\xff\xe9\xff\xe3\xff\x00\x00\xe5\xff\xdd\xff\x00\x00\xdf\xff\x00\x00\xe1\xff\x00\x00\xe7\xff\x00\x00\xfd\xff\xfe\xff\xed\xff\x00\x00\xfc\xff\x00\x00\xfa\xff\x00\x00\xfb\xff\xe4\xff\xf2\xff\xf4\xff\xef\xff\xf0\xff\xf1\xff\xea\xff\xf3\xff\xf5\xff\xe8\xff\xe2\xff\x00\x00\x00\x00\x00\x00\xe0\xff\xde\xff\xdc\xff"#

    happyCheck :: HappyAddr
    happyCheck :: HappyAddr
    happyCheck = Addr# -> HappyAddr
    HappyA# Addr#
    "\xff\xff\x0f\x00\x01\x00\x02\x00\x02\x00\x04\x00\x01\x00\x02\x00\x07\x00\x04\x00\x08\x00\x09\x00\x07\x00\x0c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x01\x00\x02\x00\x0b\x00\x04\x00\x01\x00\x10\x00\x07\x00\x02\x00\x03\x00\x04\x00\x0b\x00\x01\x00\x02\x00\x08\x00\x04\x00\x09\x00\x0b\x00\x07\x00\x09\x00\x01\x00\x0a\x00\x00\x00\x01\x00\x02\x00\x05\x00\x04\x00\x01\x00\x02\x00\x07\x00\x04\x00\x01\x00\x02\x00\x07\x00\x04\x00\x01\x00\x02\x00\x07\x00\x04\x00\x01\x00\x02\x00\x07\x00\x04\x00\x0a\x00\x03\x00\x07\x00\x0d\x00\x0e\x00\x0f\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x05\x00\x06\x00\x07\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x06\x00\x01\x00\x07\x00\x07\x00\x03\x00\x02\x00\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"#

    happyTable :: HappyAddr
    happyTable :: HappyAddr
    happyTable = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x20\x00\x16\x00\x03\x00\x13\x00\x04\x00\x02\x00\x03\x00\x05\x00\x04\x00\x14\x00\x15\x00\x05\x00\x17\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x18\x00\x03\x00\x0f\x00\x04\x00\x07\x00\xff\xff\x05\x00\x08\x00\x09\x00\x0a\x00\x19\x00\x1a\x00\x03\x00\x0e\x00\x04\x00\x2e\x00\x0f\x00\x05\x00\x28\x00\x07\x00\x1b\x00\x0f\x00\x02\x00\x03\x00\x35\x00\x04\x00\x1c\x00\x03\x00\x05\x00\x04\x00\x37\x00\x03\x00\x05\x00\x04\x00\x36\x00\x03\x00\x05\x00\x04\x00\x35\x00\x03\x00\x05\x00\x04\x00\x2a\x00\x2e\x00\x05\x00\x2b\x00\x2c\x00\x2d\x00\x30\x00\x2b\x00\x2c\x00\x2d\x00\x10\x00\x11\x00\x12\x00\x1e\x00\x1f\x00\x26\x00\x27\x00\x24\x00\x25\x00\x22\x00\x23\x00\x34\x00\x07\x00\x33\x00\x20\x00\x28\x00\x31\x00\x30\x00\x00\x00\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#
       -> Located Token
       -> Int#
       -> Happy_IntList
       -> HappyStk HappyAbsSyn
       -> [Located Token]
       -> Either (Located Token) HappyAbsSyn)
    happyReduceArr = (Int, Int)
    -> [(Int,
         Int#
         -> Located Token
         -> Int#
         -> Happy_IntList
         -> HappyStk HappyAbsSyn
         -> [Located Token]
         -> Either (Located Token) HappyAbsSyn)]
    -> Array
         Int
         (Int#
          -> Located Token
          -> Int#
          -> Happy_IntList
          -> HappyStk HappyAbsSyn
          -> [Located Token]
          -> Either (Located Token) HappyAbsSyn)
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    Happy_Data_Array.array (Int
    1, Int
    35) [
    	(Int
    1 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_1),
    	(Int
    2 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_2),
    	(Int
    3 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_3),
    	(Int
    4 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_4),
    	(Int
    5 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_5),
    	(Int
    6 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_6),
    	(Int
    7 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_7),
    	(Int
    8 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_8),
    	(Int
    9 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_9),
    	(Int
    10 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_10),
    	(Int
    11 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_11),
    	(Int
    12 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_12),
    	(Int
    13 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_13),
    	(Int
    14 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_14),
    	(Int
    15 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_15),
    	(Int
    16 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_16),
    	(Int
    17 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_17),
    	(Int
    18 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_18),
    	(Int
    19 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_19),
    	(Int
    20 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_20),
    	(Int
    21 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_21),
    	(Int
    22 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_22),
    	(Int
    23 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_23),
    	(Int
    24 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_24),
    	(Int
    25 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_25),
    	(Int
    26 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_26),
    	(Int
    27 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_27),
    	(Int
    28 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_28),
    	(Int
    29 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_29),
    	(Int
    30 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_30),
    	(Int
    31 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_31),
    	(Int
    32 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_32),
    	(Int
    33 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_33),
    	(Int
    34 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_34),
    	(Int
    35 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_35)
    	]

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

    happyReduce_1 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_1 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_2  Int#
    0# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_1
    happyReduction_1 :: p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_1 p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Value Position
    happy_var_1) ->
    	Value Position -> HappyAbsSyn
    happyIn4
    		 (Value Position
    happy_var_1
    	)}

    happyReduce_2 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_2 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_2  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_2
    happyReduction_2 :: p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_2 p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_1 of { (HappyWrap8 [Section Position]
    happy_var_1) ->
    	Value Position -> HappyAbsSyn
    happyIn5
    		 ([Section Position] -> Value Position
    sections [Section Position]
    happy_var_1
    	)}

    happyReduce_3 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_3 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_3
    happyReduction_3 :: p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_3 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 (T.Bullet Text
    "*")) ->
    	case HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    happy_x_2 of { (HappyWrap14 [Value Position]
    happy_var_2) ->
    	Value Position -> HappyAbsSyn
    happyIn5
    		 (Position -> [Value Position] -> Value Position
    forall a. a -> [Value a] -> Value a
    List Position
    happy_var_1 ([Value Position] -> [Value Position]
    forall a. [a] -> [a]
    reverse [Value Position]
    happy_var_2)
    	)}}

    happyReduce_4 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_4 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_4
    happyReduction_4 :: p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_4 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 (T.Bullet Text
    "-")) ->
    	case HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    happy_x_2 of { (HappyWrap16 [Value Position]
    happy_var_2) ->
    	Value Position -> HappyAbsSyn
    happyIn5
    		 (Position -> [Value Position] -> Value Position
    forall a. a -> [Value a] -> Value a
    List Position
    happy_var_1 ([Value Position] -> [Value Position]
    forall a. [a] -> [a]
    reverse [Value Position]
    happy_var_2)
    	)}}

    happyReduce_5 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_5 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_5
    happyReduction_5 :: p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_5 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 (T.Bullet Text
    "+")) ->
    	case HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    happy_x_2 of { (HappyWrap15 [Value Position]
    happy_var_2) ->
    	Value Position -> HappyAbsSyn
    happyIn5
    		 (Position -> [Value Position] -> Value Position
    forall a. a -> [Value a] -> Value a
    List Position
    happy_var_1 ([Value Position] -> [Value Position]
    forall a. [a] -> [a]
    reverse [Value Position]
    happy_var_2)
    	)}}

    happyReduce_6 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_6 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    1# HappyAbsSyn -> HappyAbsSyn
    happyReduction_6
    happyReduction_6 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_6 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_1 of { (HappyWrap6 Value Position
    happy_var_1) ->
    	Value Position -> HappyAbsSyn
    happyIn5
    		 (Value Position
    happy_var_1
    	)}

    happyReduce_7 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_7 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    2# HappyAbsSyn -> HappyAbsSyn
    happyReduction_7
    happyReduction_7 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_7 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { Located Token
    happy_var_1 ->
    	Value Position -> HappyAbsSyn
    happyIn6
    		 (Located Token -> Value Position
    number   Located Token
    happy_var_1
    	)}

    happyReduce_8 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_8 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    2# HappyAbsSyn -> HappyAbsSyn
    happyReduction_8
    happyReduction_8 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_8 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { Located Token
    happy_var_1 ->
    	Value Position -> HappyAbsSyn
    happyIn6
    		 (Located Token -> Value Position
    text     Located Token
    happy_var_1
    	)}

    happyReduce_9 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_9 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    2# HappyAbsSyn -> HappyAbsSyn
    happyReduction_9
    happyReduction_9 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_9 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { Located Token
    happy_var_1 ->
    	Value Position -> HappyAbsSyn
    happyIn6
    		 (Located Token -> Value Position
    atom     Located Token
    happy_var_1
    	)}

    happyReduce_10 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_10 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    2# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_10
    happyReduction_10 :: p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_10 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 Token
    T.OpenMap) ->
    	case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_2 of { (HappyWrap9 [Section Position]
    happy_var_2) ->
    	Value Position -> HappyAbsSyn
    happyIn6
    		 (Position -> [Section Position] -> Value Position
    forall a. a -> [Section a] -> Value a
    Sections Position
    happy_var_1 ([Section Position] -> [Section Position]
    forall a. [a] -> [a]
    reverse [Section Position]
    happy_var_2)
    	)}}

    happyReduce_11 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_11 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    2# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_11
    happyReduction_11 :: p -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_11 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 Token
    T.OpenList) ->
    	case HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    happy_x_2 of { (HappyWrap12 [Value Position]
    happy_var_2) ->
    	Value Position -> HappyAbsSyn
    happyIn6
    		 (Position -> [Value Position] -> Value Position
    forall a. a -> [Value a] -> Value a
    List     Position
    happy_var_1 ([Value Position] -> [Value Position]
    forall a. [a] -> [a]
    reverse [Value Position]
    happy_var_2)
    	)}}

    happyReduce_12 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_12 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn
        -> Located Token -> Either (Located Token) HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyMonadReduce Int#
    3# Int#
    2# HappyStk HappyAbsSyn
    -> Located Token -> Either (Located Token) HappyAbsSyn
    forall {p}.
    HappyStk HappyAbsSyn -> p -> Either (Located Token) HappyAbsSyn
    happyReduction_12
    happyReduction_12 :: HappyStk HappyAbsSyn -> p -> Either (Located Token) HappyAbsSyn
    happyReduction_12 (HappyAbsSyn
    happy_x_3 `HappyStk`
    	HappyAbsSyn
    happy_x_2 `HappyStk`
    	HappyAbsSyn
    happy_x_1 `HappyStk`
    	HappyStk HappyAbsSyn
    happyRest) p
    tk
    	 = Either (Located Token) (Value Position)
    -> (Value Position -> Either (Located Token) HappyAbsSyn)
    -> Either (Located Token) HappyAbsSyn
    forall a b.
    Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    happyThen ((case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 Token
    T.OpenMap) ->
    	( Position -> Either (Located Token) (Value Position)
    forall a. Position -> Either (Located Token) a
    untermSections Position
    happy_var_1)})
    	) (\Value Position
    r -> HappyAbsSyn -> Either (Located Token) HappyAbsSyn
    forall a. a -> Either (Located Token) a
    happyReturn (Value Position -> HappyAbsSyn
    happyIn6 Value Position
    r))

    happyReduce_13 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_13 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn
        -> Located Token -> Either (Located Token) HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyMonadReduce Int#
    3# Int#
    2# HappyStk HappyAbsSyn
    -> Located Token -> Either (Located Token) HappyAbsSyn
    forall {p}.
    HappyStk HappyAbsSyn -> p -> Either (Located Token) HappyAbsSyn
    happyReduction_13
    happyReduction_13 :: HappyStk HappyAbsSyn -> p -> Either (Located Token) HappyAbsSyn
    happyReduction_13 (HappyAbsSyn
    happy_x_3 `HappyStk`
    	HappyAbsSyn
    happy_x_2 `HappyStk`
    	HappyAbsSyn
    happy_x_1 `HappyStk`
    	HappyStk HappyAbsSyn
    happyRest) p
    tk
    	 = Either (Located Token) (Value Position)
    -> (Value Position -> Either (Located Token) HappyAbsSyn)
    -> Either (Located Token) HappyAbsSyn
    forall a b.
    Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    happyThen ((case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (Located Position
    happy_var_1 Token
    T.OpenList) ->
    	( Position -> Either (Located Token) (Value Position)
    forall a. Position -> Either (Located Token) a
    untermList     Position
    happy_var_1)})
    	) (\Value Position
    r -> HappyAbsSyn -> Either (Located Token) HappyAbsSyn
    forall a. a -> Either (Located Token) a
    happyReturn (Value Position -> HappyAbsSyn
    happyIn6 Value Position
    r))

    happyReduce_14 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_14 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_14
    happyReduction_14 :: p -> HappyAbsSyn
    happyReduction_14 p
    happy_x_1
    	 =  () -> HappyAbsSyn
    happyIn7
    		 (()
    	)

    happyReduce_15 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_15 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_15
    happyReduction_15 :: p -> HappyAbsSyn
    happyReduction_15 p
    happy_x_1
    	 =  () -> HappyAbsSyn
    happyIn7
    		 (()
    	)

    happyReduce_16 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_16 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_16
    happyReduction_16 :: p -> HappyAbsSyn
    happyReduction_16 p
    happy_x_1
    	 =  () -> HappyAbsSyn
    happyIn7
    		 (()
    	)

    happyReduce_17 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_17 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    4# HappyAbsSyn -> HappyAbsSyn
    happyReduction_17
    happyReduction_17 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_17 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_1 of { (HappyWrap11 Section Position
    happy_var_1) ->
    	[Section Position] -> HappyAbsSyn
    happyIn8
    		 ([Section Position
    happy_var_1]
    	)}

    happyReduce_18 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_18 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    4# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_18
    happyReduction_18 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_18 HappyAbsSyn
    happy_x_3
    	p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_1 of { (HappyWrap8 [Section Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_3 of { (HappyWrap11 Section Position
    happy_var_3) ->
    	[Section Position] -> HappyAbsSyn
    happyIn8
    		 (Section Position
    happy_var_3 Section Position -> [Section Position] -> [Section Position]
    forall a. a -> [a] -> [a]
    : [Section Position]
    happy_var_1
    	)}}

    happyReduce_19 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_19 = Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_0  Int#
    5# HappyAbsSyn
    happyReduction_19
    happyReduction_19 :: HappyAbsSyn
    happyReduction_19  =  [Section Position] -> HappyAbsSyn
    happyIn9
    		 ([]
    	)

    happyReduce_20 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_20 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_20
    happyReduction_20 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_20 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    happy_x_1 of { (HappyWrap10 [Section Position]
    happy_var_1) ->
    	[Section Position] -> HappyAbsSyn
    happyIn9
    		 ([Section Position]
    happy_var_1
    	)}

    happyReduce_21 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_21 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_2  Int#
    5# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_21
    happyReduction_21 :: p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_21 p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    happy_x_1 of { (HappyWrap10 [Section Position]
    happy_var_1) ->
    	[Section Position] -> HappyAbsSyn
    happyIn9
    		 ([Section Position]
    happy_var_1
    	)}

    happyReduce_22 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_22 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    6# HappyAbsSyn -> HappyAbsSyn
    happyReduction_22
    happyReduction_22 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_22 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_1 of { (HappyWrap11 Section Position
    happy_var_1) ->
    	[Section Position] -> HappyAbsSyn
    happyIn10
    		 ([Section Position
    happy_var_1]
    	)}

    happyReduce_23 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_23 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    6# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_23
    happyReduction_23 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_23 HappyAbsSyn
    happy_x_3
    	p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    happy_x_1 of { (HappyWrap10 [Section Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_3 of { (HappyWrap11 Section Position
    happy_var_3) ->
    	[Section Position] -> HappyAbsSyn
    happyIn10
    		 (Section Position
    happy_var_3 Section Position -> [Section Position] -> [Section Position]
    forall a. a -> [a] -> [a]
    : [Section Position]
    happy_var_1
    	)}}

    happyReduce_24 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_24 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_2  Int#
    7# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_24
    happyReduction_24 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_24 HappyAbsSyn
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { Located Token
    happy_var_1 ->
    	case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_2 of { (HappyWrap5 Value Position
    happy_var_2) ->
    	Section Position -> HappyAbsSyn
    happyIn11
    		 (Located Token -> Value Position -> Section Position
    section Located Token
    happy_var_1 Value Position
    happy_var_2
    	)}}

    happyReduce_25 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_25 = Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_0  Int#
    8# HappyAbsSyn
    happyReduction_25
    happyReduction_25 :: HappyAbsSyn
    happyReduction_25  =  [Value Position] -> HappyAbsSyn
    happyIn12
    		 ([]
    	)

    happyReduce_26 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_26 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    8# HappyAbsSyn -> HappyAbsSyn
    happyReduction_26
    happyReduction_26 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_26 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 [Value Position]
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn12
    		 ([Value Position]
    happy_var_1
    	)}

    happyReduce_27 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_27 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_2  Int#
    8# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_27
    happyReduction_27 :: p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_27 p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 [Value Position]
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn12
    		 ([Value Position]
    happy_var_1
    	)}

    happyReduce_28 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_28 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    9# HappyAbsSyn -> HappyAbsSyn
    happyReduction_28
    happyReduction_28 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_28 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_1 of { (HappyWrap6 Value Position
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn13
    		 ([Value Position
    happy_var_1]
    	)}

    happyReduce_29 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_29 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_3  Int#
    9# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_29
    happyReduction_29 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_29 HappyAbsSyn
    happy_x_3
    	p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 [Value Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_3 of { (HappyWrap6 Value Position
    happy_var_3) ->
    	[Value Position] -> HappyAbsSyn
    happyIn13
    		 (Value Position
    happy_var_3 Value Position -> [Value Position] -> [Value Position]
    forall a. a -> [a] -> [a]
    : [Value Position]
    happy_var_1
    	)}}

    happyReduce_30 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_30 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    10# HappyAbsSyn -> HappyAbsSyn
    happyReduction_30
    happyReduction_30 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_30 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Value Position
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn14
    		 ([Value Position
    happy_var_1]
    	)}

    happyReduce_31 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_31 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce Int#
    4# Int#
    10# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_31
    happyReduction_31 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_31 (HappyAbsSyn
    happy_x_4 `HappyStk`
    	HappyAbsSyn
    happy_x_3 `HappyStk`
    	HappyAbsSyn
    happy_x_2 `HappyStk`
    	HappyAbsSyn
    happy_x_1 `HappyStk`
    	HappyStk HappyAbsSyn
    happyRest)
    	 = case HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    happy_x_1 of { (HappyWrap14 [Value Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_4 of { (HappyWrap5 Value Position
    happy_var_4) ->
    	[Value Position] -> HappyAbsSyn
    happyIn14
    		 (Value Position
    happy_var_4 Value Position -> [Value Position] -> [Value Position]
    forall a. a -> [a] -> [a]
    : [Value Position]
    happy_var_1
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_32 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_32 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    11# HappyAbsSyn -> HappyAbsSyn
    happyReduction_32
    happyReduction_32 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_32 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Value Position
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn15
    		 ([Value Position
    happy_var_1]
    	)}

    happyReduce_33 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_33 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce Int#
    4# Int#
    11# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_33
    happyReduction_33 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_33 (HappyAbsSyn
    happy_x_4 `HappyStk`
    	HappyAbsSyn
    happy_x_3 `HappyStk`
    	HappyAbsSyn
    happy_x_2 `HappyStk`
    	HappyAbsSyn
    happy_x_1 `HappyStk`
    	HappyStk HappyAbsSyn
    happyRest)
    	 = case HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    happy_x_1 of { (HappyWrap15 [Value Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_4 of { (HappyWrap5 Value Position
    happy_var_4) ->
    	[Value Position] -> HappyAbsSyn
    happyIn15
    		 (Value Position
    happy_var_4 Value Position -> [Value Position] -> [Value Position]
    forall a. a -> [a] -> [a]
    : [Value Position]
    happy_var_1
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_34 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_34 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happySpecReduce_1  Int#
    12# HappyAbsSyn -> HappyAbsSyn
    happyReduction_34
    happyReduction_34 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_34 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Value Position
    happy_var_1) ->
    	[Value Position] -> HappyAbsSyn
    happyIn16
    		 ([Value Position
    happy_var_1]
    	)}

    happyReduce_35 :: Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce_35 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyReduce Int#
    4# Int#
    12# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_35
    happyReduction_35 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_35 (HappyAbsSyn
    happy_x_4 `HappyStk`
    	HappyAbsSyn
    happy_x_3 `HappyStk`
    	HappyAbsSyn
    happy_x_2 `HappyStk`
    	HappyAbsSyn
    happy_x_1 `HappyStk`
    	HappyStk HappyAbsSyn
    happyRest)
    	 = case HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    happy_x_1 of { (HappyWrap16 [Value Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_4 of { (HappyWrap5 Value Position
    happy_var_4) ->
    	[Value Position] -> HappyAbsSyn
    happyIn16
    		 (Value Position
    happy_var_4 Value Position -> [Value Position] -> [Value Position]
    forall a. a -> [a] -> [a]
    : [Value Position]
    happy_var_1
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyNewToken :: Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyNewToken Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk [] =
    	Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyDoAction Int#
    16# Located Token
    forall a. a
    notHappyAtAll Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk []

    happyNewToken Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk (Located Token
    tk:[Located Token]
    tks) =
    	let cont :: Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    i = Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Located Token]
    -> Either (Located Token) HappyAbsSyn
    happyDoAction Int#
    i Located Token
    tk Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk [Located Token]
    tks in
    	case Located Token
    tk of {
    	Located Position
    _ T.Section{} -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    1#;
    	Located Position
    _ T.String{} -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    2#;
    	Located Position
    _ T.Atom{} -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    3#;
    	Located Position
    _ T.Number{} -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    4#;
    	Located Position
    happy_dollar_dollar (T.Bullet Text
    "*") -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    5#;
    	Located Position
    happy_dollar_dollar (T.Bullet Text
    "+") -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    6#;
    	Located Position
    happy_dollar_dollar (T.Bullet Text
    "-") -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    7#;
    	Located Position
    happy_dollar_dollar Token
    T.OpenList -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    8#;
    	Located Position
    _ Token
    T.Comma -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    9#;
    	Located Position
    _ Token
    T.CloseList -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    10#;
    	Located Position
    happy_dollar_dollar Token
    T.OpenMap -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    11#;
    	Located Position
    _ Token
    T.CloseMap -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    12#;
    	Located Position
    _ Token
    T.LayoutSep -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    13#;
    	Located Position
    _ Token
    T.LayoutEnd -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    14#;
    	Located Position
    _ Token
    T.EOF -> Int# -> Either (Located Token) HappyAbsSyn
    cont Int#
    15#;
    	Located Token
    _ -> ([Located Token], [String]) -> Either (Located Token) HappyAbsSyn
    forall a. ([Located Token], [String]) -> Either (Located Token) a
    happyError' ((Located Token
    tkLocated Token -> [Located Token] -> [Located Token]
    forall a. a -> [a] -> [a]
    :[Located Token]
    tks), [])
    	}

    happyError_ :: [String]
    -> Int#
    -> Located Token
    -> [Located Token]
    -> Either (Located Token) a
    happyError_ [String]
    explist Int#
    16# Located Token
    tk [Located Token]
    tks = ([Located Token], [String]) -> Either (Located Token) a
    forall a. ([Located Token], [String]) -> Either (Located Token) a
    happyError' ([Located Token]
    tks, [String]
    explist)
    happyError_ [String]
    explist Int#
    _ Located Token
    tk [Located Token]
    tks = ([Located Token], [String]) -> Either (Located Token) a
    forall a. ([Located Token], [String]) -> Either (Located Token) a
    happyError' ((Located Token
    tkLocated Token -> [Located Token] -> [Located Token]
    forall a. a -> [a] -> [a]
    :[Located Token]
    tks), [String]
    explist)

    happyThen :: () => Either (Located Token) a -> (a -> Either (Located Token) b) -> Either (Located Token) b
    happyThen :: forall a b.
    Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    happyThen = Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    forall a b.
    Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    (Prelude.>>=)
    happyReturn :: () => a -> Either (Located Token) a
    happyReturn :: forall a. a -> Either (Located Token) a
    happyReturn = (a -> Either (Located Token) a
    forall a. a -> Either (Located Token) 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 -> Either (Located Token) a
    happyReturn1 :: forall a b. a -> b -> Either (Located Token) a
    happyReturn1 = \a
    a b
    tks -> (forall (m :: * -> *) a. Monad m => a -> m a
    Prelude.return) a
    a
    happyError' :: () => ([(Located Token)], [Prelude.String]) -> Either (Located Token) a
    happyError' :: forall a. ([Located Token], [String]) -> Either (Located Token) a
    happyError' = (\([Located Token]
    tokens, [String]
    _) -> [Located Token] -> Either (Located Token) a
    forall a. [Located Token] -> Either (Located Token) a
    errorP [Located Token]
    tokens)
    config :: [Located Token] -> Either (Located Token) (Value Position)
    config [Located Token]
    tks = Either (Located Token) (Value Position)
    happySomeParser where
     happySomeParser :: Either (Located Token) (Value Position)
    happySomeParser = Either (Located Token) HappyAbsSyn
    -> (HappyAbsSyn -> Either (Located Token) (Value Position))
    -> Either (Located Token) (Value Position)
    forall a b.
    Either (Located Token) a
    -> (a -> Either (Located Token) b) -> Either (Located Token) b
    happyThen (Int# -> [Located Token] -> Either (Located Token) HappyAbsSyn
    happyParse Int#
    0# [Located Token]
    tks) (\HappyAbsSyn
    x -> Value Position -> Either (Located Token) (Value Position)
    forall a. a -> Either (Located Token) a
    happyReturn (let {(HappyWrap4 Value Position
    x') = HappyAbsSyn -> HappyWrap4
    happyOut4 HappyAbsSyn
    x} in Value Position
    x'))

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

    -- | Convert number token to number value. This needs a custom
    -- function like this because there are multiple values matched from
    -- the constructor.
    number :: Located Token -> Value Position
    number :: Located Token -> Value Position
    number = \(Located Position
    a (T.Number Number
    n)) -> Position -> Number -> Value Position
    forall a. a -> Number -> Value a
    Number Position
    a Number
    n

    section :: Located Token -> Value Position -> Section Position
    section :: Located Token -> Value Position -> Section Position
    section = \(Located Position
    a (T.Section Text
    k)) Value Position
    v -> Position -> Text -> Value Position -> Section Position
    forall a. a -> Text -> Value a -> Section a
    Section Position
    a Text
    k Value Position
    v

    sections :: [Section Position] -> Value Position
    sections :: [Section Position] -> Value Position
    sections [Section Position]
    xxs = Position -> [Section Position] -> Value Position
    forall a. a -> [Section a] -> Value a
    Sections (Section Position -> Position
    forall a. Section a -> a
    sectionAnn Section Position
    x) (Section Position
    xSection Position -> [Section Position] -> [Section Position]
    forall a. a -> [a] -> [a]
    :[Section Position]
    xs)
      where Section Position
    x:[Section Position]
    xs = [Section Position] -> [Section Position]
    forall a. [a] -> [a]
    reverse [Section Position]
    xxs

    text :: Located Token -> Value Position
    text :: Located Token -> Value Position
    text = \(Located Position
    a (T.String Text
    x)) -> Position -> Text -> Value Position
    forall a. a -> Text -> Value a
    Text Position
    a Text
    x

    atom :: Located Token -> Value Position
    atom :: Located Token -> Value Position
    atom = \(Located Position
    a (T.Atom Text
    x)) -> Position -> Atom -> Value Position
    forall a. a -> Atom -> Value a
    Atom Position
    a (Text -> Atom
    MkAtom Text
    x)

    errorP :: [Located Token] -> Either (Located Token) a
    errorP :: forall a. [Located Token] -> Either (Located Token) a
    errorP [Located Token]
    xs = Located Token -> Either (Located Token) a
    forall a b. a -> Either a b
    Left ([Located Token] -> Located Token
    forall a. HasCallStack => [a] -> a
    head [Located Token]
    xs)

    untermSections :: Position -> Either (Located Token) a
    untermSections :: forall a. Position -> Either (Located Token) a
    untermSections Position
    p = Located Token -> Either (Located Token) a
    forall a b. a -> Either a b
    Left (Position -> Token -> Located Token
    forall a. Position -> a -> Located a
    Located Position
    p (Error -> Token
    T.Error Error
    T.UntermSections))

    untermList :: Position -> Either (Located Token) a
    untermList :: forall a. Position -> Either (Located Token) a
    untermList Position
    p = Located Token -> Either (Located Token) a
    forall a b. a -> Either a b
    Left (Position -> Token -> Located Token
    forall a. Position -> a -> Located a
    Located Position
    p (Error -> Token
    T.Error Error
    T.UntermList))

    -- | Attempt to parse a layout annotated token stream or
    -- the token that caused the parse to fail.
    parseValue ::
      [Located Token]                         {- ^ layout annotated token stream -} ->
      Either (Located Token) (Value Position) {- ^ token at failure or result -}
    parseValue :: [Located Token] -> Either (Located Token) (Value Position)
    parseValue = [Located Token] -> Either (Located Token) (Value Position)
    config
    {-# 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.