    {-# OPTIONS_GHC -w #-}
    {-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}
    #if __GLASGOW_HASKELL__ >= 710
    {-# OPTIONS_GHC -XPartialTypeSignatures #-}
    #endif
    {-|
    Module      : Toml.Syntax.Parser
    Description : Raw TOML expression parser
    Copyright   : (c) Eric Mertens, 2023
    License     : ISC
    Maintainer  : emertens@gmail.com

    This module parses TOML tokens into a list of raw,
    uninterpreted sections and assignments.

    -}
    module Toml.Syntax.Parser (
      -- * Types
      Expr(..),
      SectionKind(..),
      Val(..),
      Key,

      -- * Parser
      parseRawToml,
      ) where

    import Data.List.NonEmpty (NonEmpty)
    import Data.List.NonEmpty qualified as NonEmpty
    import Data.Text (Text)
    import Toml.Syntax.Lexer (Context(..), Token(..))
    import Toml.Syntax.ParserUtils
    import Toml.Syntax.Position (Located(Located, locThing), Position)
    import Toml.Syntax.Position (startPos)
    import Toml.Syntax.Types (Expr(..), Key, Val(..), SectionKind(..))
    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 ([Expr Position])
    happyIn4 :: ([Expr Position]) -> (HappyAbsSyn )
    happyIn4 :: [Expr Position] -> HappyAbsSyn
    happyIn4 [Expr Position]
    x = HappyWrap4 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Expr Position] -> HappyWrap4
    HappyWrap4 [Expr 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 ([Expr Position])
    happyIn5 :: ([Expr Position]) -> (HappyAbsSyn )
    happyIn5 :: [Expr Position] -> HappyAbsSyn
    happyIn5 [Expr Position]
    x = HappyWrap5 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Expr Position] -> HappyWrap5
    HappyWrap5 [Expr 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 ((Key Position, Val Position))
    happyIn6 :: ((Key Position, Val Position)) -> (HappyAbsSyn )
    happyIn6 :: (Key Position, Val Position) -> HappyAbsSyn
    happyIn6 (Key Position, Val Position)
    x = HappyWrap6 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ((Key Position, Val Position) -> HappyWrap6
    HappyWrap6 (Key Position, Val 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 (Key Position)
    happyIn7 :: (Key Position) -> (HappyAbsSyn )
    happyIn7 :: Key Position -> HappyAbsSyn
    happyIn7 Key Position
    x = HappyWrap7 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap7
    HappyWrap7 Key Position
    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 ((Position, Text))
    happyIn8 :: ((Position, Text)) -> (HappyAbsSyn )
    happyIn8 :: (Position, Text) -> HappyAbsSyn
    happyIn8 (Position, Text)
    x = HappyWrap8 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ((Position, Text) -> HappyWrap8
    HappyWrap8 (Position, Text)
    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 (Val Position)
    happyIn9 :: (Val Position) -> (HappyAbsSyn )
    happyIn9 :: Val Position -> HappyAbsSyn
    happyIn9 Val Position
    x = HappyWrap9 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Val Position -> HappyWrap9
    HappyWrap9 Val 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 (Located [(Key Position, Val Position)])
    happyIn10 :: (Located [(Key Position, Val Position)]) -> (HappyAbsSyn )
    happyIn10 :: Located [(Key Position, Val Position)] -> HappyAbsSyn
    happyIn10 Located [(Key Position, Val Position)]
    x = HappyWrap10 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Located [(Key Position, Val Position)] -> HappyWrap10
    HappyWrap10 Located [(Key Position, Val 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 ([(Key Position, Val Position)])
    happyIn11 :: ([(Key Position, Val Position)]) -> (HappyAbsSyn )
    happyIn11 :: [(Key Position, Val Position)] -> HappyAbsSyn
    happyIn11 [(Key Position, Val Position)]
    x = HappyWrap11 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([(Key Position, Val Position)] -> HappyWrap11
    HappyWrap11 [(Key Position, Val 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 (Located [Val Position])
    happyIn12 :: (Located [Val Position]) -> (HappyAbsSyn )
    happyIn12 :: Located [Val Position] -> HappyAbsSyn
    happyIn12 Located [Val Position]
    x = HappyWrap12 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Located [Val Position] -> HappyWrap12
    HappyWrap12 Located [Val 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 ([Val Position])
    happyIn13 :: ([Val Position]) -> (HappyAbsSyn )
    happyIn13 :: [Val Position] -> HappyAbsSyn
    happyIn13 [Val Position]
    x = HappyWrap13 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# ([Val Position] -> HappyWrap13
    HappyWrap13 [Val 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 (())
    happyIn14 :: (()) -> (HappyAbsSyn )
    happyIn14 :: () -> HappyAbsSyn
    happyIn14 ()
    x = HappyWrap14 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap14
    HappyWrap14 ()
    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 (())
    happyIn15 :: (()) -> (HappyAbsSyn )
    happyIn15 :: () -> HappyAbsSyn
    happyIn15 ()
    x = HappyWrap15 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap15
    HappyWrap15 ()
    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 (())
    happyIn16 :: (()) -> (HappyAbsSyn )
    happyIn16 :: () -> HappyAbsSyn
    happyIn16 ()
    x = HappyWrap16 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap16
    HappyWrap16 ()
    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 #-}
    newtype HappyWrap17 = HappyWrap17 (())
    happyIn17 :: (()) -> (HappyAbsSyn )
    happyIn17 :: () -> HappyAbsSyn
    happyIn17 ()
    x = HappyWrap17 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap17
    HappyWrap17 ()
    x)
    {-# INLINE happyIn17 #-}
    happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
    happyOut17 :: HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap17
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut17 #-}
    newtype HappyWrap18 = HappyWrap18 (NonEmpty ([Expr Position]))
    happyIn18 :: (NonEmpty ([Expr Position])) -> (HappyAbsSyn )
    happyIn18 :: NonEmpty [Expr Position] -> HappyAbsSyn
    happyIn18 NonEmpty [Expr Position]
    x = HappyWrap18 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (NonEmpty [Expr Position] -> HappyWrap18
    HappyWrap18 NonEmpty [Expr Position]
    x)
    {-# INLINE happyIn18 #-}
    happyOut18 :: (HappyAbsSyn ) -> HappyWrap18
    happyOut18 :: HappyAbsSyn -> HappyWrap18
    happyOut18 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap18
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut18 #-}
    newtype HappyWrap19 = HappyWrap19 (NonEmpty ((Position, Text)))
    happyIn19 :: (NonEmpty ((Position, Text))) -> (HappyAbsSyn )
    happyIn19 :: Key Position -> HappyAbsSyn
    happyIn19 Key Position
    x = HappyWrap19 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap19
    HappyWrap19 Key Position
    x)
    {-# INLINE happyIn19 #-}
    happyOut19 :: (HappyAbsSyn ) -> HappyWrap19
    happyOut19 :: HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap19
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut19 #-}
    newtype HappyWrap20 = HappyWrap20 (NonEmpty ([Expr Position]))
    happyIn20 :: (NonEmpty ([Expr Position])) -> (HappyAbsSyn )
    happyIn20 :: NonEmpty [Expr Position] -> HappyAbsSyn
    happyIn20 NonEmpty [Expr Position]
    x = HappyWrap20 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (NonEmpty [Expr Position] -> HappyWrap20
    HappyWrap20 NonEmpty [Expr Position]
    x)
    {-# INLINE happyIn20 #-}
    happyOut20 :: (HappyAbsSyn ) -> HappyWrap20
    happyOut20 :: HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap20
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut20 #-}
    newtype HappyWrap21 = HappyWrap21 (NonEmpty ((Position, Text)))
    happyIn21 :: (NonEmpty ((Position, Text))) -> (HappyAbsSyn )
    happyIn21 :: Key Position -> HappyAbsSyn
    happyIn21 Key Position
    x = HappyWrap21 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap21
    HappyWrap21 Key Position
    x)
    {-# INLINE happyIn21 #-}
    happyOut21 :: (HappyAbsSyn ) -> HappyWrap21
    happyOut21 :: HappyAbsSyn -> HappyWrap21
    happyOut21 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap21
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut21 #-}
    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\x00\x8a\x01\x00\x00\x00\x28\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x06\x00\x00\x00\xa0\x18\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xf0\x1f\x00\x00\x00\x00\x00\x00\x00\x80\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xfc\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\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_parseRawToml_",String
    "toml",String
    "expression",String
    "keyval",String
    "key",String
    "simplekey",String
    "val",String
    "inlinetable",String
    "inlinetablekeyvals",String
    "array",String
    "arrayvalues",String
    "newlines",String
    "rhs",String
    "lhs",String
    "pop",String
    "sepBy1__expression__NEWLINE__",String
    "sepBy1__simplekey__'.'__",String
    "sepBy1___expression__NEWLINE__",String
    "sepBy1___simplekey__'.'__",String
    "','",String
    "'='",String
    "NEWLINE",String
    "'.'",String
    "'['",String
    "']'",String
    "'[['",String
    "']]'",String
    "'{'",String
    "'}'",String
    "BAREKEY",String
    "STRING",String
    "MLSTRING",String
    "BOOL",String
    "INTEGER",String
    "FLOAT",String
    "OFFSETDATETIME",String
    "LOCALDATETIME",String
    "LOCALDATE",String
    "LOCALTIME",String
    "%eof"]
            bit_start :: Int
    bit_start = Int
    st Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Prelude.* Int
    42
            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
    42
            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
    41]
            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#
    "\x69\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x1c\x00\x3d\x00\x3d\x00\x00\x00\x00\x00\x22\x00\x39\x00\x33\x00\x3d\x00\x69\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x45\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\xfe\xff\x00\x00\x3b\x00\x00\x00\x44\x00\x00\x00\x28\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x58\x00\x00\x00\x4a\x00\x5d\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xfe\xff\x00\x00\x00\x00\x5b\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x67\x00\x00\x00"#

    happyGotoOffsets :: HappyAddr
    happyGotoOffsets :: HappyAddr
    happyGotoOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\x13\x00\x17\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x1b\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\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\x2c\x00\x6c\x00\x57\x00\x6e\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x66\x00\x6f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x71\x00\x00\x00\x2e\x00\x00\x00\x60\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\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#
    "\xfd\xff\x00\x00\xd9\xff\xfc\xff\xde\xff\xd7\xff\xfe\xff\xf8\xff\xdb\xff\xda\xff\x00\x00\x00\x00\xf7\xff\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\x00\x00\xdc\xff\xd8\xff\xd6\xff\xfb\xff\xfa\xff\xde\xff\xf9\xff\xeb\xff\xec\xff\x00\x00\x00\x00\xf2\xff\xf1\xff\xf3\xff\xf5\xff\xf4\xff\xee\xff\xed\xff\xf0\xff\xef\xff\xe0\xff\xe0\xff\xde\xff\xe0\xff\xdc\xff\xe7\xff\x00\x00\xdf\xff\xdc\xff\xe0\xff\xdc\xff\x00\x00\xe5\xff\x00\x00\xe0\xff\xe2\xff\x00\x00\xe0\xff\xe8\xff\xdc\xff\xea\xff\xde\xff\xe4\xff\xe0\xff\x00\x00\xe6\xff\x00\x00\xe9\xff\xe3\xff\xe1\xff"#

    happyCheck :: HappyAddr
    happyCheck :: HappyAddr
    happyCheck = Addr# -> HappyAddr
    HappyA# Addr#
    "\xff\xff\x03\x00\x05\x00\x06\x00\x06\x00\x08\x00\x03\x00\x09\x00\x0b\x00\x0c\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x01\x00\x02\x00\x03\x00\x04\x00\x01\x00\x02\x00\x03\x00\x04\x00\x04\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x01\x00\x0f\x00\x03\x00\x11\x00\x02\x00\x03\x00\x04\x00\x02\x00\x03\x00\x04\x00\x07\x00\x03\x00\x04\x00\x0a\x00\x15\x00\x0d\x00\x06\x00\x0f\x00\x0d\x00\x11\x00\x0f\x00\x03\x00\x11\x00\x0f\x00\x08\x00\x11\x00\x03\x00\x04\x00\x02\x00\x0b\x00\x0c\x00\x0b\x00\x0c\x00\x05\x00\x09\x00\x01\x00\x03\x00\x0a\x00\x0f\x00\x09\x00\x11\x00\x06\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x05\x00\x06\x00\x06\x00\x08\x00\x09\x00\x06\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x06\x00\x0a\x00\x08\x00\x0a\x00\x03\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x0b\x00\x07\x00\x04\x00\x0d\x00\x0d\x00\x0b\x00\x0c\x00\x0a\x00\x0d\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\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\x30\x00\x1a\x00\x1b\x00\xdc\xff\x1c\x00\x13\x00\xdd\xff\x1d\x00\x1e\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x0e\x00\x02\x00\x03\x00\x04\x00\x05\x00\x02\x00\x03\x00\x04\x00\x05\x00\x15\x00\x03\x00\x04\x00\x05\x00\x12\x00\x06\x00\x07\x00\x08\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x3a\x00\x07\x00\x30\x00\x09\x00\x2d\x00\x04\x00\x05\x00\x41\x00\x04\x00\x05\x00\x2b\x00\x10\x00\x05\x00\x2c\x00\xff\xff\x2e\x00\x18\x00\x07\x00\x42\x00\x09\x00\x07\x00\x30\x00\x09\x00\x07\x00\x19\x00\x09\x00\x0f\x00\x05\x00\x15\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x2a\x00\x29\x00\x37\x00\x30\x00\x3b\x00\x07\x00\xdd\xff\x09\x00\x35\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x31\x00\x1b\x00\x3f\x00\x1c\x00\x32\x00\x45\x00\x1d\x00\x1e\x00\x33\x00\x3f\x00\x1b\x00\x3d\x00\x1c\x00\x44\x00\x30\x00\x1d\x00\x1e\x00\x40\x00\x0b\x00\x13\x00\x0c\x00\x16\x00\x19\x00\x38\x00\x0d\x00\x0e\x00\x2a\x00\x35\x00\x30\x00\x37\x00\x3d\x00\x3b\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyReduceArr :: forall r.
    Array
      Int
      (Int#
       -> Located Token
       -> Int#
       -> Happy_IntList
       -> HappyStk HappyAbsSyn
       -> Parser r HappyAbsSyn)
    happyReduceArr = (Int, Int)
    -> [(Int,
         Int#
         -> Located Token
         -> Int#
         -> Happy_IntList
         -> HappyStk HappyAbsSyn
         -> Parser r HappyAbsSyn)]
    -> Array
         Int
         (Int#
          -> Located Token
          -> Int#
          -> Happy_IntList
          -> HappyStk HappyAbsSyn
          -> Parser r HappyAbsSyn)
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    Happy_Data_Array.array (Int
    1, Int
    41) [
    	(Int
    1 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_1),
    	(Int
    2 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_2),
    	(Int
    3 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_3),
    	(Int
    4 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_4),
    	(Int
    5 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_5),
    	(Int
    6 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_6),
    	(Int
    7 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_7),
    	(Int
    8 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_8),
    	(Int
    9 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_9),
    	(Int
    10 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_10),
    	(Int
    11 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_11),
    	(Int
    12 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_12),
    	(Int
    13 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_13),
    	(Int
    14 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_14),
    	(Int
    15 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_15),
    	(Int
    16 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_16),
    	(Int
    17 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_17),
    	(Int
    18 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_18),
    	(Int
    19 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_19),
    	(Int
    20 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_20),
    	(Int
    21 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_21),
    	(Int
    22 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_22),
    	(Int
    23 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_23),
    	(Int
    24 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_24),
    	(Int
    25 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_25),
    	(Int
    26 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_26),
    	(Int
    27 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_27),
    	(Int
    28 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_28),
    	(Int
    29 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_29),
    	(Int
    30 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_30),
    	(Int
    31 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_31),
    	(Int
    32 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_32),
    	(Int
    33 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_33),
    	(Int
    34 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_34),
    	(Int
    35 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_35),
    	(Int
    36 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_36),
    	(Int
    37 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_37),
    	(Int
    38 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_38),
    	(Int
    39 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_39),
    	(Int
    40 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_40),
    	(Int
    41 , Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_41)
    	]

    happy_n_terms :: Int
    happy_n_terms = Int
    22 :: Prelude.Int
    happy_n_nonterms :: Int
    happy_n_nonterms = Int
    18 :: Prelude.Int

    happyReduce_1 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_1 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_1 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    0# HappyAbsSyn -> HappyAbsSyn
    happyReduction_1
    happyReduction_1 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_1 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap18
    happyOut18 HappyAbsSyn
    happy_x_1 of { (HappyWrap18 NonEmpty [Expr Position]
    happy_var_1) ->
    	[Expr Position] -> HappyAbsSyn
    happyIn4
    		 (NonEmpty [Expr Position] -> [Expr Position]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat NonEmpty [Expr Position]
    happy_var_1
    	)}

    happyReduce_2 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_2 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_2 = Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_0  Int#
    1# HappyAbsSyn
    happyReduction_2
    happyReduction_2 :: HappyAbsSyn
    happyReduction_2  =  [Expr Position] -> HappyAbsSyn
    happyIn5
    		 ([]
    	)

    happyReduce_3 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_3 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_3 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    1# HappyAbsSyn -> HappyAbsSyn
    happyReduction_3
    happyReduction_3 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_3 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_1 of { (HappyWrap6 (Key Position, Val Position)
    happy_var_1) ->
    	[Expr Position] -> HappyAbsSyn
    happyIn5
    		 ([(Key Position -> Val Position -> Expr Position)
    -> (Key Position, Val Position) -> Expr Position
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Key Position -> Val Position -> Expr Position
    forall a. Key a -> Val a -> Expr a
    KeyValExpr (Key Position, Val Position)
    happy_var_1]
    	)}

    happyReduce_4 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_4 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_4 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_3  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_4
    happyReduction_4 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_4 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    happy_x_2 of { (HappyWrap7 Key Position
    happy_var_2) ->
    	[Expr Position] -> HappyAbsSyn
    happyIn5
    		 ([Key Position -> Expr Position
    forall a. Key a -> Expr a
    TableExpr      Key Position
    happy_var_2    ]
    	)}

    happyReduce_5 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_5 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_5 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_3  Int#
    1# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_5
    happyReduction_5 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_5 p
    happy_x_3
    	HappyAbsSyn
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    happy_x_2 of { (HappyWrap7 Key Position
    happy_var_2) ->
    	[Expr Position] -> HappyAbsSyn
    happyIn5
    		 ([Key Position -> Expr Position
    forall a. Key a -> Expr a
    ArrayTableExpr Key Position
    happy_var_2    ]
    	)}

    happyReduce_6 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_6 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_6 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    5# Int#
    2# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_6
    happyReduction_6 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_6 (HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> HappyWrap7
    happyOut7 HappyAbsSyn
    happy_x_1 of { (HappyWrap7 Key Position
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_5 of { (HappyWrap9 Val Position
    happy_var_5) ->
    	(Key Position, Val Position) -> HappyAbsSyn
    happyIn6
    		 ((Key Position
    happy_var_1,Val Position
    happy_var_5)
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_7 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_7 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    happyReduction_7
    happyReduction_7 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_7 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    happy_x_1 of { (HappyWrap19 Key Position
    happy_var_1) ->
    	Key Position -> HappyAbsSyn
    happyIn7
    		 (Key Position
    happy_var_1
    	)}

    happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_8 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_8 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    4# HappyAbsSyn -> HappyAbsSyn
    happyReduction_8
    happyReduction_8 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_8 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asBareKey        -> Just Located Text
    happy_var_1)) ->
    	(Position, Text) -> HappyAbsSyn
    happyIn8
    		 ((Position -> Text -> (Position, Text))
    -> Located Text -> (Position, Text)
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal (,) Located Text
    happy_var_1
    	)}

    happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_9 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_9 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    4# HappyAbsSyn -> HappyAbsSyn
    happyReduction_9
    happyReduction_9 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_9 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asString         -> Just Located Text
    happy_var_1)) ->
    	(Position, Text) -> HappyAbsSyn
    happyIn8
    		 ((Position -> Text -> (Position, Text))
    -> Located Text -> (Position, Text)
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal (,) Located Text
    happy_var_1
    	)}

    happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_10 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_10 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_10
    happyReduction_10 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_10 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Integer)
    -> Located Token -> Maybe (Located Integer)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Integer
    asInteger        -> Just Located Integer
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Integer -> Val Position)
    -> Located Integer -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Integer -> Val Position
    forall a. a -> Integer -> Val a
    ValInteger    Located Integer
    happy_var_1
    	)}

    happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_11 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_11 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_11
    happyReduction_11 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_11 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Double) -> Located Token -> Maybe (Located Double)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Double
    asFloat          -> Just Located Double
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Double -> Val Position)
    -> Located Double -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Double -> Val Position
    forall a. a -> Double -> Val a
    ValFloat      Located Double
    happy_var_1
    	)}

    happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_12 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_12 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_12
    happyReduction_12 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_12 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Bool) -> Located Token -> Maybe (Located Bool)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Bool
    asBool           -> Just Located Bool
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Bool -> Val Position) -> Located Bool -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Bool -> Val Position
    forall a. a -> Bool -> Val a
    ValBool       Located Bool
    happy_var_1
    	)}

    happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_13 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_13 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_13
    happyReduction_13 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_13 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asString         -> Just Located Text
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Text -> Val Position) -> Located Text -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Text -> Val Position
    forall a. a -> Text -> Val a
    ValString     Located Text
    happy_var_1
    	)}

    happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_14 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_14 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_14
    happyReduction_14 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_14 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asMlString       -> Just Located Text
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Text -> Val Position) -> Located Text -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Text -> Val Position
    forall a. a -> Text -> Val a
    ValString     Located Text
    happy_var_1
    	)}

    happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_15 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_15 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_15
    happyReduction_15 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_15 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe Day) -> Located Token -> Maybe (Located Day)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Day
    asLocalDate      -> Just Located Day
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> Day -> Val Position) -> Located Day -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> Day -> Val Position
    forall a. a -> Day -> Val a
    ValDay        Located Day
    happy_var_1
    	)}

    happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_16 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_16 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_16
    happyReduction_16 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_16 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe TimeOfDay)
    -> Located Token -> Maybe (Located TimeOfDay)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe TimeOfDay
    asLocalTime      -> Just Located TimeOfDay
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> TimeOfDay -> Val Position)
    -> Located TimeOfDay -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> TimeOfDay -> Val Position
    forall a. a -> TimeOfDay -> Val a
    ValTimeOfDay  Located TimeOfDay
    happy_var_1
    	)}

    happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_17 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_17 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_17
    happyReduction_17 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_17 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe ZonedTime)
    -> Located Token -> Maybe (Located ZonedTime)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe ZonedTime
    asOffsetDateTime -> Just Located ZonedTime
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> ZonedTime -> Val Position)
    -> Located ZonedTime -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> ZonedTime -> Val Position
    forall a. a -> ZonedTime -> Val a
    ValZonedTime  Located ZonedTime
    happy_var_1
    	)}

    happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_18 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_18 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_18
    happyReduction_18 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_18 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (((Token -> Maybe LocalTime)
    -> Located Token -> Maybe (Located LocalTime)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe LocalTime
    asLocalDateTime  -> Just Located LocalTime
    happy_var_1)) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> LocalTime -> Val Position)
    -> Located LocalTime -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> LocalTime -> Val Position
    forall a. a -> LocalTime -> Val a
    ValLocalTime  Located LocalTime
    happy_var_1
    	)}

    happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_19 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_19 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_19
    happyReduction_19 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_19 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    happy_x_1 of { (HappyWrap12 Located [Val Position]
    happy_var_1) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> [Val Position] -> Val Position)
    -> Located [Val Position] -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> [Val Position] -> Val Position
    forall a. a -> [Val a] -> Val a
    ValArray      Located [Val Position]
    happy_var_1
    	)}

    happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_20 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_20 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r 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 Located [(Key Position, Val Position)]
    happy_var_1) ->
    	Val Position -> HappyAbsSyn
    happyIn9
    		 ((Position -> [(Key Position, Val Position)] -> Val Position)
    -> Located [(Key Position, Val Position)] -> Val Position
    forall a b. (Position -> a -> b) -> Located a -> b
    locVal Position -> [(Key Position, Val Position)] -> Val Position
    forall a. a -> [(Key a, Val a)] -> Val a
    ValTable      Located [(Key Position, Val Position)]
    happy_var_1
    	)}

    happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_21 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_21 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    6# Int#
    6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_21
    happyReduction_21 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_21 (HappyAbsSyn
    happy_x_6 `HappyStk`
    	HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokCurlyO) ->
    	case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_3 of { (HappyWrap11 [(Key Position, Val Position)]
    happy_var_3) ->
    	Located [(Key Position, Val Position)] -> HappyAbsSyn
    happyIn10
    		 (Position
    -> [(Key Position, Val Position)]
    -> Located [(Key Position, Val Position)]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 ([(Key Position, Val Position)] -> [(Key Position, Val Position)]
    forall a. [a] -> [a]
    reverse [(Key Position, Val Position)]
    happy_var_3)
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_22 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_22 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    8# Int#
    6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_22
    happyReduction_22 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_22 (HappyAbsSyn
    happy_x_8 `HappyStk`
    	HappyAbsSyn
    happy_x_7 `HappyStk`
    	HappyAbsSyn
    happy_x_6 `HappyStk`
    	HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokCurlyO) ->
    	case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_3 of { (HappyWrap11 [(Key Position, Val Position)]
    happy_var_3) ->
    	Located [(Key Position, Val Position)] -> HappyAbsSyn
    happyIn10
    		 (Position
    -> [(Key Position, Val Position)]
    -> Located [(Key Position, Val Position)]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 ([(Key Position, Val Position)] -> [(Key Position, Val Position)]
    forall a. [a] -> [a]
    reverse [(Key Position, Val Position)]
    happy_var_3)
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_23 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_23 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    5# Int#
    6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_23
    happyReduction_23 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_23 (HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokCurlyO) ->
    	Located [(Key Position, Val Position)] -> HappyAbsSyn
    happyIn10
    		 (Position
    -> [(Key Position, Val Position)]
    -> Located [(Key Position, Val Position)]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 []
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}

    happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_24 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_24 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_2  Int#
    7# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_24
    happyReduction_24 :: HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_24 HappyAbsSyn
    happy_x_2
    	p
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_2 of { (HappyWrap6 (Key Position, Val Position)
    happy_var_2) ->
    	[(Key Position, Val Position)] -> HappyAbsSyn
    happyIn11
    		 ([(Key Position, Val Position)
    happy_var_2]
    	)}

    happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_25 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_25 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    5# Int#
    7# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_25
    happyReduction_25 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_25 (HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_1 of { (HappyWrap11 [(Key Position, Val Position)]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_5 of { (HappyWrap6 (Key Position, Val Position)
    happy_var_5) ->
    	[(Key Position, Val Position)] -> HappyAbsSyn
    happyIn11
    		 ((Key Position, Val Position)
    happy_var_5 (Key Position, Val Position)
    -> [(Key Position, Val Position)] -> [(Key Position, Val Position)]
    forall a. a -> [a] -> [a]
    : [(Key Position, Val Position)]
    happy_var_1
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_26 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_26 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    5# Int#
    8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_26
    happyReduction_26 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_26 (HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokSquareO) ->
    	Located [Val Position] -> HappyAbsSyn
    happyIn12
    		 (Position -> [Val Position] -> Located [Val Position]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 []
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}

    happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_27 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_27 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    6# Int#
    8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_27
    happyReduction_27 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_27 (HappyAbsSyn
    happy_x_6 `HappyStk`
    	HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokSquareO) ->
    	case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_4 of { (HappyWrap13 [Val Position]
    happy_var_4) ->
    	Located [Val Position] -> HappyAbsSyn
    happyIn12
    		 (Position -> [Val Position] -> Located [Val Position]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 ([Val Position] -> [Val Position]
    forall a. [a] -> [a]
    reverse [Val Position]
    happy_var_4)
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_28 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_28 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    8# Int#
    8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_28
    happyReduction_28 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_28 (HappyAbsSyn
    happy_x_8 `HappyStk`
    	HappyAbsSyn
    happy_x_7 `HappyStk`
    	HappyAbsSyn
    happy_x_6 `HappyStk`
    	HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> Located Token
    happyOutTok HappyAbsSyn
    happy_x_2 of { (Located Position
    happy_var_2 Token
    TokSquareO) ->
    	case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_4 of { (HappyWrap13 [Val Position]
    happy_var_4) ->
    	Located [Val Position] -> HappyAbsSyn
    happyIn12
    		 (Position -> [Val Position] -> Located [Val Position]
    forall a. Position -> a -> Located a
    Located Position
    happy_var_2 ([Val Position] -> [Val Position]
    forall a. [a] -> [a]
    reverse [Val Position]
    happy_var_4)
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_29 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_29 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_2  Int#
    9# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_29
    happyReduction_29 :: p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_29 p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_1 of { (HappyWrap9 Val Position
    happy_var_1) ->
    	[Val Position] -> HappyAbsSyn
    happyIn13
    		 ([Val Position
    happy_var_1]
    	)}

    happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_30 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_30 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce Int#
    5# Int#
    9# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_30
    happyReduction_30 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_30 (HappyAbsSyn
    happy_x_5 `HappyStk`
    	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 -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 [Val Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_4 of { (HappyWrap9 Val Position
    happy_var_4) ->
    	[Val Position] -> HappyAbsSyn
    happyIn13
    		 (Val Position
    happy_var_4 Val Position -> [Val Position] -> [Val Position]
    forall a. a -> [a] -> [a]
    : [Val Position]
    happy_var_1
    	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}

    happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_31 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_31 = Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> HappyAbsSyn
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_0  Int#
    10# HappyAbsSyn
    happyReduction_31
    happyReduction_31 :: HappyAbsSyn
    happyReduction_31  =  () -> HappyAbsSyn
    happyIn14
    		 (()
    	)

    happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_32 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_32 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_2  Int#
    10# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> p -> HappyAbsSyn
    happyReduction_32
    happyReduction_32 :: p -> p -> HappyAbsSyn
    happyReduction_32 p
    happy_x_2
    	p
    happy_x_1
    	 =  () -> HappyAbsSyn
    happyIn14
    		 (()
    	)

    happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_33 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_33 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyMonadReduce Int#
    0# Int#
    11# HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
    forall {p} {p} {r}. p -> p -> Parser r HappyAbsSyn
    happyReduction_33
    happyReduction_33 :: p -> p -> Parser r HappyAbsSyn
    happyReduction_33 (p
    happyRest) p
    tk
    	 = Parser r () -> (() -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen ((( Context -> Parser r ()
    forall r. Context -> Parser r ()
    push Context
    ValueContext))
    	) (\()
    r -> HappyAbsSyn -> Parser r HappyAbsSyn
    forall a r. a -> Parser r a
    happyReturn (() -> HappyAbsSyn
    happyIn15 ()
    r))

    happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_34 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_34 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyMonadReduce Int#
    0# Int#
    12# HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
    forall {p} {p} {r}. p -> p -> Parser r HappyAbsSyn
    happyReduction_34
    happyReduction_34 :: p -> p -> Parser r HappyAbsSyn
    happyReduction_34 (p
    happyRest) p
    tk
    	 = Parser r () -> (() -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen ((( Context -> Parser r ()
    forall r. Context -> Parser r ()
    push Context
    TableContext))
    	) (\()
    r -> HappyAbsSyn -> Parser r HappyAbsSyn
    forall a r. a -> Parser r a
    happyReturn (() -> HappyAbsSyn
    happyIn16 ()
    r))

    happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_35 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_35 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyMonadReduce Int#
    0# Int#
    13# HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
    forall {p} {p} {r}. p -> p -> Parser r HappyAbsSyn
    happyReduction_35
    happyReduction_35 :: p -> p -> Parser r HappyAbsSyn
    happyReduction_35 (p
    happyRest) p
    tk
    	 = Parser r () -> (() -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen ((( Parser r ()
    forall r. Parser r ()
    pop))
    	) (\()
    r -> HappyAbsSyn -> Parser r HappyAbsSyn
    forall a r. a -> Parser r a
    happyReturn (() -> HappyAbsSyn
    happyIn17 ()
    r))

    happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_36 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_36 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    14# HappyAbsSyn -> HappyAbsSyn
    happyReduction_36
    happyReduction_36 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_36 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    happy_x_1 of { (HappyWrap20 NonEmpty [Expr Position]
    happy_var_1) ->
    	NonEmpty [Expr Position] -> HappyAbsSyn
    happyIn18
    		 (NonEmpty [Expr Position] -> NonEmpty [Expr Position]
    forall a. NonEmpty a -> NonEmpty a
    NonEmpty.reverse NonEmpty [Expr Position]
    happy_var_1
    	)}

    happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_37 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_37 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    15# HappyAbsSyn -> HappyAbsSyn
    happyReduction_37
    happyReduction_37 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_37 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap21
    happyOut21 HappyAbsSyn
    happy_x_1 of { (HappyWrap21 Key Position
    happy_var_1) ->
    	Key Position -> HappyAbsSyn
    happyIn19
    		 (Key Position -> Key Position
    forall a. NonEmpty a -> NonEmpty a
    NonEmpty.reverse Key Position
    happy_var_1
    	)}

    happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_38 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_38 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    16# HappyAbsSyn -> HappyAbsSyn
    happyReduction_38
    happyReduction_38 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_38 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 [Expr Position]
    happy_var_1) ->
    	NonEmpty [Expr Position] -> HappyAbsSyn
    happyIn20
    		 ([Expr Position] -> NonEmpty [Expr Position]
    forall a. a -> NonEmpty a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure [Expr Position]
    happy_var_1
    	)}

    happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_39 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_39 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_3  Int#
    16# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_39
    happyReduction_39 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_39 HappyAbsSyn
    happy_x_3
    	p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    happy_x_1 of { (HappyWrap20 NonEmpty [Expr Position]
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_3 of { (HappyWrap5 [Expr Position]
    happy_var_3) ->
    	NonEmpty [Expr Position] -> HappyAbsSyn
    happyIn20
    		 ([Expr Position]
    -> NonEmpty [Expr Position] -> NonEmpty [Expr Position]
    forall a. a -> NonEmpty a -> NonEmpty a
    NonEmpty.cons [Expr Position]
    happy_var_3 NonEmpty [Expr Position]
    happy_var_1
    	)}}

    happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_40 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_40 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_1  Int#
    17# HappyAbsSyn -> HappyAbsSyn
    happyReduction_40
    happyReduction_40 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_40 HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_1 of { (HappyWrap8 (Position, Text)
    happy_var_1) ->
    	Key Position -> HappyAbsSyn
    happyIn21
    		 ((Position, Text) -> Key Position
    forall a. a -> NonEmpty a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Position, Text)
    happy_var_1
    	)}

    happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
    happyReduce_41 :: forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyReduce_41 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall {r}.
    Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happySpecReduce_3  Int#
    17# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_41
    happyReduction_41 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_41 HappyAbsSyn
    happy_x_3
    	p
    happy_x_2
    	HappyAbsSyn
    happy_x_1
    	 =  case HappyAbsSyn -> HappyWrap21
    happyOut21 HappyAbsSyn
    happy_x_1 of { (HappyWrap21 Key Position
    happy_var_1) ->
    	case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_3 of { (HappyWrap8 (Position, Text)
    happy_var_3) ->
    	Key Position -> HappyAbsSyn
    happyIn21
    		 ((Position, Text) -> Key Position -> Key Position
    forall a. a -> NonEmpty a -> NonEmpty a
    NonEmpty.cons (Position, Text)
    happy_var_3 Key Position
    happy_var_1
    	)}}

    happyNewToken :: forall r.
    Int#
    -> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
    happyNewToken Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
    	= (Located Token -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
    forall r a. (Located Token -> Parser r a) -> Parser r a
    lexerP(\Located Token
    tk ->
    	let cont :: Int# -> Parser r HappyAbsSyn
    cont Int#
    i = Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyDoAction Int#
    i Located Token
    tk Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk in
    	case Located Token
    tk of {
    	Located Position
    _ Token
    TokEOF -> Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    forall r.
    Int#
    -> Located Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> Parser r HappyAbsSyn
    happyDoAction Int#
    21# Located Token
    tk Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk;
    	Located Position
    happy_dollar_dollar Token
    TokComma -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    1#;
    	Located Position
    happy_dollar_dollar Token
    TokEquals -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    2#;
    	Located Position
    happy_dollar_dollar Token
    TokNewline -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    3#;
    	Located Position
    happy_dollar_dollar Token
    TokPeriod -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    4#;
    	Located Position
    happy_dollar_dollar Token
    TokSquareO -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    5#;
    	Located Position
    happy_dollar_dollar Token
    TokSquareC -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    6#;
    	Located Position
    happy_dollar_dollar Token
    Tok2SquareO -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    7#;
    	Located Position
    happy_dollar_dollar Token
    Tok2SquareC -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    8#;
    	Located Position
    happy_dollar_dollar Token
    TokCurlyO -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    9#;
    	Located Position
    happy_dollar_dollar Token
    TokCurlyC -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    10#;
    	((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asBareKey        -> Just Located Text
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    11#;
    	((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asString         -> Just Located Text
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    12#;
    	((Token -> Maybe Text) -> Located Token -> Maybe (Located Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Text
    asMlString       -> Just Located Text
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    13#;
    	((Token -> Maybe Bool) -> Located Token -> Maybe (Located Bool)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Bool
    asBool           -> Just Located Bool
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    14#;
    	((Token -> Maybe Integer)
    -> Located Token -> Maybe (Located Integer)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Integer
    asInteger        -> Just Located Integer
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    15#;
    	((Token -> Maybe Double) -> Located Token -> Maybe (Located Double)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Double
    asFloat          -> Just Located Double
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    16#;
    	((Token -> Maybe ZonedTime)
    -> Located Token -> Maybe (Located ZonedTime)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe ZonedTime
    asOffsetDateTime -> Just Located ZonedTime
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    17#;
    	((Token -> Maybe LocalTime)
    -> Located Token -> Maybe (Located LocalTime)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe LocalTime
    asLocalDateTime  -> Just Located LocalTime
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    18#;
    	((Token -> Maybe Day) -> Located Token -> Maybe (Located Day)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe Day
    asLocalDate      -> Just Located Day
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    19#;
    	((Token -> Maybe TimeOfDay)
    -> Located Token -> Maybe (Located TimeOfDay)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Located a -> f (Located b)
    traverse Token -> Maybe TimeOfDay
    asLocalTime      -> Just Located TimeOfDay
    happy_dollar_dollar) -> Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    cont Int#
    20#;
    	Located Token
    _ -> (Located Token, [String]) -> Parser r HappyAbsSyn
    forall r a. (Located Token, [String]) -> Parser r a
    happyError' (Located Token
    tk, [])
    	})

    happyError_ :: [String] -> Int# -> Located Token -> Parser r a
    happyError_ [String]
    explist Int#
    21# Located Token
    tk = (Located Token, [String]) -> Parser r a
    forall r a. (Located Token, [String]) -> Parser r a
    happyError' (Located Token
    tk, [String]
    explist)
    happyError_ [String]
    explist Int#
    _ Located Token
    tk = (Located Token, [String]) -> Parser r a
    forall r a. (Located Token, [String]) -> Parser r a
    happyError' (Located Token
    tk, [String]
    explist)

    happyThen :: () => Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen :: forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen = (Parser r a -> (a -> Parser r b) -> Parser r b
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    thenP)
    happyReturn :: () => a -> Parser r a
    happyReturn :: forall a r. a -> Parser r a
    happyReturn = (a -> Parser r a
    forall a r. a -> Parser r a
    pureP)
    happyParse :: () => Happy_GHC_Exts.Int# -> Parser r (HappyAbsSyn )

    happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )

    happyDoAction :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )

    happyReduceArr :: () => Happy_Data_Array.Array Prelude.Int (Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn ))

    happyThen1 :: () => Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen1 :: forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen1 = Parser r a -> (a -> Parser r b) -> Parser r b
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen
    happyReturn1 :: () => a -> Parser r a
    happyReturn1 :: forall a r. a -> Parser r a
    happyReturn1 = a -> Parser r a
    forall a r. a -> Parser r a
    happyReturn
    happyError' :: () => ((Located Token), [Prelude.String]) -> Parser r a
    happyError' :: forall r a. (Located Token, [String]) -> Parser r a
    happyError' (Located Token, [String])
    tk = (\(Located Token
    tokens, [String]
    _) -> Located Token -> Parser r a
    forall r a. Located Token -> Parser r a
    errorP Located Token
    tokens) (Located Token, [String])
    tk
    parseRawToml_ :: Parser r [Expr Position]
    parseRawToml_ = Parser r [Expr Position]
    forall {r}. Parser r [Expr Position]
    happySomeParser where
     happySomeParser :: Parser r [Expr Position]
    happySomeParser = Parser r HappyAbsSyn
    -> (HappyAbsSyn -> Parser r [Expr Position])
    -> Parser r [Expr Position]
    forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
    happyThen (Int# -> Parser r HappyAbsSyn
    forall {r}. Int# -> Parser r HappyAbsSyn
    happyParse Int#
    0#) (\HappyAbsSyn
    x -> [Expr Position] -> Parser r [Expr Position]
    forall a r. a -> Parser r a
    happyReturn (let {(HappyWrap4 [Expr Position]
    x') = HappyAbsSyn -> HappyWrap4
    happyOut4 HappyAbsSyn
    x} in [Expr Position]
    x'))

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

    -- | Parse a list of tokens either returning the first unexpected
    -- token or a list of the TOML statements in the file to be
    -- processed by "Toml.Semantics".
    parseRawToml :: Text -> Either (Located String) [Expr Position]
    parseRawToml :: Text -> Either (Located String) [Expr Position]
    parseRawToml = Parser [Expr Position] [Expr Position]
    -> Context
    -> Located Text
    -> Either (Located String) [Expr Position]
    forall r.
    Parser r r -> Context -> Located Text -> Either (Located String) r
    runParser Parser [Expr Position] [Expr Position]
    forall {r}. Parser r [Expr Position]
    parseRawToml_ Context
    TopContext (Located Text -> Either (Located String) [Expr Position])
    -> (Text -> Located Text)
    -> Text
    -> Either (Located String) [Expr Position]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Position -> Text -> Located Text
    forall a. Position -> a -> Located a
    Located Position
    startPos
    {-# 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.