{-# 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.0

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 (Located [Val Position])
happyIn11 :: (Located [Val Position]) -> (HappyAbsSyn )
happyIn11 :: Located [Val Position] -> HappyAbsSyn
happyIn11 Located [Val Position]
x = HappyWrap11 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Located [Val Position] -> HappyWrap11
HappyWrap11 Located [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 ([Val Position])
happyIn12 :: ([Val Position]) -> (HappyAbsSyn )
happyIn12 :: [Val Position] -> HappyAbsSyn
happyIn12 [Val Position]
x = HappyWrap12 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Val Position] -> HappyWrap12
HappyWrap12 [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 (())
happyIn13 :: (()) -> (HappyAbsSyn )
happyIn13 :: () -> HappyAbsSyn
happyIn13 ()
x = HappyWrap13 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap13
HappyWrap13 ()
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 ([((Key Position, Val Position))])
happyIn17 :: ([((Key Position, Val Position))]) -> (HappyAbsSyn )
happyIn17 :: [(Key Position, Val Position)] -> HappyAbsSyn
happyIn17 [(Key Position, Val Position)]
x = HappyWrap17 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([(Key Position, Val Position)] -> HappyWrap17
HappyWrap17 [(Key Position, Val Position)]
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 ((Key Position, Val Position)))
happyIn20 :: (NonEmpty ((Key Position, Val Position))) -> (HappyAbsSyn )
happyIn20 :: NonEmpty (Key Position, Val Position) -> HappyAbsSyn
happyIn20 NonEmpty (Key Position, Val Position)
x = HappyWrap20 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (NonEmpty (Key Position, Val Position) -> HappyWrap20
HappyWrap20 NonEmpty (Key Position, Val 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 ([Expr Position]))
happyIn21 :: (NonEmpty ([Expr Position])) -> (HappyAbsSyn )
happyIn21 :: NonEmpty [Expr Position] -> HappyAbsSyn
happyIn21 NonEmpty [Expr Position]
x = HappyWrap21 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (NonEmpty [Expr Position] -> HappyWrap21
HappyWrap21 NonEmpty [Expr 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 #-}
newtype HappyWrap22 = HappyWrap22 (NonEmpty ((Position, Text)))
happyIn22 :: (NonEmpty ((Position, Text))) -> (HappyAbsSyn )
happyIn22 :: Key Position -> HappyAbsSyn
happyIn22 Key Position
x = HappyWrap22 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap22
HappyWrap22 Key Position
x)
{-# INLINE happyIn22 #-}
happyOut22 :: (HappyAbsSyn ) -> HappyWrap22
happyOut22 :: HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap22
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut22 #-}
newtype HappyWrap23 = HappyWrap23 (NonEmpty ((Key Position, Val Position)))
happyIn23 :: (NonEmpty ((Key Position, Val Position))) -> (HappyAbsSyn )
happyIn23 :: NonEmpty (Key Position, Val Position) -> HappyAbsSyn
happyIn23 NonEmpty (Key Position, Val Position)
x = HappyWrap23 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (NonEmpty (Key Position, Val Position) -> HappyWrap23
HappyWrap23 NonEmpty (Key Position, Val Position)
x)
{-# INLINE happyIn23 #-}
happyOut23 :: (HappyAbsSyn ) -> HappyWrap23
happyOut23 :: HappyAbsSyn -> HappyWrap23
happyOut23 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap23
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut23 #-}
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\x28\x06\x00\x00\x00\x80\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x06\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\x00\x04\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x28\x06\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\x00\xc0\x7f\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\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xfc\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xc0\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\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
"array",String
"arrayvalues",String
"newlines",String
"rhs",String
"lhs",String
"pop",String
"sepBy__keyval__','__",String
"sepBy1__expression__NEWLINE__",String
"sepBy1__simplekey__'.'__",String
"sepBy1__keyval__','__",String
"sepBy1___expression__NEWLINE__",String
"sepBy1___simplekey__'.'__",String
"sepBy1___keyval__','__",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
44
        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
44
        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
43]
        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#
"\x65\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x06\x00\x16\x00\x16\x00\x00\x00\x00\x00\x0e\x00\x1f\x00\x23\x00\x16\x00\x65\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x27\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x16\x00\x30\x00\x00\x00\x41\x00\x3f\x00\x00\x00\x00\x00\x40\x00\x00\x00\x46\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x5b\x00\x00\x00"#

happyGotoOffsets :: HappyAddr
happyGotoOffsets :: HappyAddr
happyGotoOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x01\x00\x1c\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x35\x00\x00\x00\x37\x00\x00\x00\x00\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\x22\x00\x62\x00\x55\x00\x00\x00\x63\x00\x00\x00\x00\x00\x39\x00\x00\x00\x64\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x6b\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\xda\xff\xfc\xff\xe2\xff\xd8\xff\xfe\xff\xf8\xff\xdd\xff\xdc\xff\x00\x00\x00\x00\xf7\xff\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\x00\x00\xe0\xff\xd9\xff\xd7\xff\xfb\xff\xfa\xff\xe2\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\xdf\xff\xe4\xff\xe2\xff\xd6\xff\xe0\xff\xde\xff\xdb\xff\x00\x00\x00\x00\xe4\xff\xe0\xff\x00\x00\xe3\xff\xe9\xff\x00\x00\xe4\xff\xe6\xff\xea\xff\xd5\xff\xe2\xff\xe8\xff\xe4\xff\x00\x00\xe7\xff\xe5\xff"#

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

happyTable :: HappyAddr
happyTable :: HappyAddr
happyTable = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x0e\x00\x02\x00\x03\x00\x04\x00\x05\x00\x13\x00\x1a\x00\x1b\x00\x1c\x00\x12\x00\x35\x00\x1d\x00\x1e\x00\xe0\xff\x06\x00\x07\x00\xe1\xff\x08\x00\x09\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x02\x00\x03\x00\x04\x00\x05\x00\x0d\x00\x0e\x00\xff\xff\x2b\x00\x04\x00\x05\x00\x19\x00\x15\x00\x18\x00\x06\x00\x07\x00\x2a\x00\x08\x00\x09\x00\x2c\x00\x30\x00\x07\x00\x2d\x00\x29\x00\x09\x00\x2e\x00\x15\x00\x03\x00\x04\x00\x05\x00\x3a\x00\x3a\x00\x04\x00\x05\x00\x10\x00\x05\x00\x0f\x00\x05\x00\x38\x00\x19\x00\x07\x00\x36\x00\x3d\x00\x09\x00\x07\x00\x35\x00\x07\x00\x09\x00\x07\x00\x09\x00\xe1\xff\x09\x00\x40\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x31\x00\x1b\x00\x1c\x00\x32\x00\x35\x00\x1d\x00\x1e\x00\x33\x00\x3d\x00\x1b\x00\x1c\x00\x16\x00\x13\x00\x1d\x00\x1e\x00\x3e\x00\x0b\x00\x2a\x00\x0c\x00\x38\x00\x00\x00\x30\x00\x0d\x00\x0e\x00\x36\x00\x3b\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyReduceArr :: 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
42) [
	(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),
	(Int
42 , 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_42)
	]

happy_n_terms :: Int
happy_n_terms = Int
22 :: Prelude.Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
20 :: 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 -> HappyWrap11
happyOut11 HappyAbsSyn
happy_x_1 of { (HappyWrap11 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#
5# Int#
6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_21
happyReduction_21 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_21 (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 -> HappyWrap17
happyOut17 HappyAbsSyn
happy_x_3 of { (HappyWrap17 [(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)]
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#
5# Int#
7# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22
happyReduction_22 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22 (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
happyIn11
		 (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_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#
6# Int#
7# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23
happyReduction_23 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23 (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 -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_4 of { (HappyWrap12 [Val Position]
happy_var_4) -> 
	Located [Val Position] -> HappyAbsSyn
happyIn11
		 (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_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#
-> 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#
7# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_24
happyReduction_24 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_24 (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 -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_4 of { (HappyWrap12 [Val Position]
happy_var_4) -> 
	Located [Val Position] -> HappyAbsSyn
happyIn11
		 (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_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#
-> (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#
8# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_25
happyReduction_25 :: p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_25 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
happyIn12
		 ([Val Position
happy_var_1]
	)}

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 -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_1 of { (HappyWrap12 [Val Position]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap9
happyOut9 HappyAbsSyn
happy_x_4 of { (HappyWrap9 Val Position
happy_var_4) -> 
	[Val Position] -> HappyAbsSyn
happyIn12
		 (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_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#
-> 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#
9# HappyAbsSyn
happyReduction_27
happyReduction_27 :: HappyAbsSyn
happyReduction_27  =  () -> HappyAbsSyn
happyIn13
		 (()
	)

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#
-> (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}. p -> p -> HappyAbsSyn
happyReduction_28
happyReduction_28 :: p -> p -> HappyAbsSyn
happyReduction_28 p
happy_x_2
	p
happy_x_1
	 =  () -> HappyAbsSyn
happyIn13
		 (()
	)

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#
-> 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#
10# HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
forall {p} {p} {r}. p -> p -> Parser r HappyAbsSyn
happyReduction_29
happyReduction_29 :: p -> p -> Parser r HappyAbsSyn
happyReduction_29 (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
happyIn14 ()
r))

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 -> 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_30
happyReduction_30 :: p -> p -> Parser r HappyAbsSyn
happyReduction_30 (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
happyIn15 ()
r))

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#
-> 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_31
happyReduction_31 :: p -> p -> Parser r HappyAbsSyn
happyReduction_31 (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
happyIn16 ()
r))

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
-> 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#
13# HappyAbsSyn
happyReduction_32
happyReduction_32 :: HappyAbsSyn
happyReduction_32  =  [(Key Position, Val Position)] -> HappyAbsSyn
happyIn17
		 ([]
	)

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#
-> (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#
13# HappyAbsSyn -> HappyAbsSyn
happyReduction_33
happyReduction_33 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_33 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap20
happyOut20 HappyAbsSyn
happy_x_1 of { (HappyWrap20 NonEmpty (Key Position, Val Position)
happy_var_1) -> 
	[(Key Position, Val Position)] -> HappyAbsSyn
happyIn17
		 (NonEmpty (Key Position, Val Position)
-> [(Key Position, Val Position)]
forall a. NonEmpty a -> [a]
NonEmpty.toList NonEmpty (Key Position, Val Position)
happy_var_1
	)}

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#
-> (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_34
happyReduction_34 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_34 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap21
happyOut21 HappyAbsSyn
happy_x_1 of { (HappyWrap21 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_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#
-> (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_35
happyReduction_35 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_35 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
happy_x_1 of { (HappyWrap22 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_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#
16# HappyAbsSyn -> HappyAbsSyn
happyReduction_36
happyReduction_36 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_36 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap23
happyOut23 HappyAbsSyn
happy_x_1 of { (HappyWrap23 NonEmpty (Key Position, Val Position)
happy_var_1) -> 
	NonEmpty (Key Position, Val Position) -> HappyAbsSyn
happyIn20
		 (NonEmpty (Key Position, Val Position)
-> NonEmpty (Key Position, Val Position)
forall a. NonEmpty a -> NonEmpty a
NonEmpty.reverse NonEmpty (Key Position, Val 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#
17# HappyAbsSyn -> HappyAbsSyn
happyReduction_37
happyReduction_37 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_37 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap5
happyOut5 HappyAbsSyn
happy_x_1 of { (HappyWrap5 [Expr Position]
happy_var_1) -> 
	NonEmpty [Expr Position] -> HappyAbsSyn
happyIn21
		 ([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_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 -> 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_38
happyReduction_38 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_38 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap21
happyOut21 HappyAbsSyn
happy_x_1 of { (HappyWrap21 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
happyIn21
		 ([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_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)
-> 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#
18# HappyAbsSyn -> HappyAbsSyn
happyReduction_39
happyReduction_39 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_39 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_1 of { (HappyWrap8 (Position, Text)
happy_var_1) -> 
	Key Position -> HappyAbsSyn
happyIn22
		 ((Position, Text) -> Key Position
forall a. a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Position, Text)
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 -> 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#
18# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_40
happyReduction_40 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_40 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
happy_x_1 of { (HappyWrap22 Key Position
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_3 of { (HappyWrap8 (Position, Text)
happy_var_3) -> 
	Key Position -> HappyAbsSyn
happyIn22
		 ((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
	)}}

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)
-> 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#
19# HappyAbsSyn -> HappyAbsSyn
happyReduction_41
happyReduction_41 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_41 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
happy_x_1 of { (HappyWrap6 (Key Position, Val Position)
happy_var_1) -> 
	NonEmpty (Key Position, Val Position) -> HappyAbsSyn
happyIn23
		 ((Key Position, Val Position)
-> NonEmpty (Key Position, Val Position)
forall a. a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Key Position, Val Position)
happy_var_1
	)}

happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_42 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_42 = 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#
19# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_42
happyReduction_42 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_42 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap23
happyOut23 HappyAbsSyn
happy_x_1 of { (HappyWrap23 NonEmpty (Key Position, Val Position)
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
happy_x_3 of { (HappyWrap6 (Key Position, Val Position)
happy_var_3) -> 
	NonEmpty (Key Position, Val Position) -> HappyAbsSyn
happyIn23
		 ((Key Position, Val Position)
-> NonEmpty (Key Position, Val Position)
-> NonEmpty (Key Position, Val Position)
forall a. a -> NonEmpty a -> NonEmpty a
NonEmpty.cons (Key Position, Val Position)
happy_var_3 NonEmpty (Key Position, Val 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.