{-# OPTIONS_GHC -w #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE PatternGuards #-}
{-# LANGUAGE NoStrictData #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE PartialTypeSignatures #-}
{-|
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 Control.Monad as Happy_Prelude
import qualified Data.Bool as Happy_Prelude
import qualified Data.Function as Happy_Prelude
import qualified Data.Int as Happy_Prelude
import qualified Data.List as Happy_Prelude
import qualified Data.Maybe as Happy_Prelude
import qualified Data.String as Happy_Prelude
import qualified Data.Tuple as Happy_Prelude
import qualified GHC.Err as Happy_Prelude
import qualified GHC.Num as Happy_Prelude
import qualified Text.Show as Happy_Prelude
import qualified Data.Array as Happy_Data_Array
import qualified Data.Bits as Bits
import qualified GHC.Exts as Happy_GHC_Exts
import Control.Applicative(Applicative(..))
import Control.Monad (ap)

-- parser produced by Happy Version 2.1.7

newtype HappyAbsSyn  = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
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 ([Expr Position])
happyIn6 :: ([Expr Position]) -> (HappyAbsSyn )
happyIn6 :: [Expr Position] -> HappyAbsSyn
happyIn6 [Expr Position]
x = HappyWrap6 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Expr Position] -> HappyWrap6
HappyWrap6 [Expr 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, Val Position))
happyIn7 :: ((Key Position, Val Position)) -> (HappyAbsSyn )
happyIn7 :: (Key Position, Val Position) -> HappyAbsSyn
happyIn7 (Key Position, Val Position)
x = HappyWrap7 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ((Key Position, Val Position) -> HappyWrap7
HappyWrap7 (Key Position, Val 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 (Key Position)
happyIn8 :: (Key Position) -> (HappyAbsSyn )
happyIn8 :: Key Position -> HappyAbsSyn
happyIn8 Key Position
x = HappyWrap8 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap8
HappyWrap8 Key Position
x)
{-# INLINE happyIn8 #-}
happyOut8 :: (HappyAbsSyn ) -> HappyWrap8
happyOut8 :: HappyAbsSyn -> HappyWrap8
happyOut8 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap8
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut8 #-}
newtype HappyWrap9 = HappyWrap9 ((Position, Text))
happyIn9 :: ((Position, Text)) -> (HappyAbsSyn )
happyIn9 :: (Position, Text) -> HappyAbsSyn
happyIn9 (Position, Text)
x = HappyWrap9 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ((Position, Text) -> HappyWrap9
HappyWrap9 (Position, Text)
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 (Val Position)
happyIn10 :: (Val Position) -> (HappyAbsSyn )
happyIn10 :: Val Position -> HappyAbsSyn
happyIn10 Val Position
x = HappyWrap10 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Val Position -> HappyWrap10
HappyWrap10 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 [(Key Position, Val Position)])
happyIn11 :: (Located [(Key Position, Val Position)]) -> (HappyAbsSyn )
happyIn11 :: Located [(Key Position, Val Position)] -> HappyAbsSyn
happyIn11 Located [(Key Position, Val Position)]
x = HappyWrap11 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Located [(Key Position, Val Position)] -> HappyWrap11
HappyWrap11 Located [(Key Position, Val Position)]
x)
{-# INLINE happyIn11 #-}
happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
happyOut11 :: HappyAbsSyn -> HappyWrap11
happyOut11 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap11
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut11 #-}
newtype HappyWrap12 = HappyWrap12 ([(Key Position, Val Position)])
happyIn12 :: ([(Key Position, Val Position)]) -> (HappyAbsSyn )
happyIn12 :: [(Key Position, Val Position)] -> HappyAbsSyn
happyIn12 [(Key Position, Val Position)]
x = HappyWrap12 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([(Key Position, Val Position)] -> HappyWrap12
HappyWrap12 [(Key Position, 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 (Located [Val Position])
happyIn13 :: (Located [Val Position]) -> (HappyAbsSyn )
happyIn13 :: Located [Val Position] -> HappyAbsSyn
happyIn13 Located [Val Position]
x = HappyWrap13 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Located [Val Position] -> HappyWrap13
HappyWrap13 Located [Val Position]
x)
{-# INLINE happyIn13 #-}
happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
happyOut13 :: HappyAbsSyn -> HappyWrap13
happyOut13 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap13
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut13 #-}
newtype HappyWrap14 = HappyWrap14 ([Val Position])
happyIn14 :: ([Val Position]) -> (HappyAbsSyn )
happyIn14 :: [Val Position] -> HappyAbsSyn
happyIn14 [Val Position]
x = HappyWrap14 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([Val Position] -> HappyWrap14
HappyWrap14 [Val Position]
x)
{-# INLINE happyIn14 #-}
happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
happyOut14 :: HappyAbsSyn -> HappyWrap14
happyOut14 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap14
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut14 #-}
newtype HappyWrap15 = HappyWrap15 (())
happyIn15 :: (()) -> (HappyAbsSyn )
happyIn15 :: () -> HappyAbsSyn
happyIn15 ()
x = HappyWrap15 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap15
HappyWrap15 ()
x)
{-# INLINE happyIn15 #-}
happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
happyOut15 :: HappyAbsSyn -> HappyWrap15
happyOut15 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap15
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut15 #-}
newtype HappyWrap16 = HappyWrap16 (())
happyIn16 :: (()) -> (HappyAbsSyn )
happyIn16 :: () -> HappyAbsSyn
happyIn16 ()
x = HappyWrap16 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap16
HappyWrap16 ()
x)
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
happyOut16 :: HappyAbsSyn -> HappyWrap16
happyOut16 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap16
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut16 #-}
newtype HappyWrap17 = HappyWrap17 (())
happyIn17 :: (()) -> (HappyAbsSyn )
happyIn17 :: () -> HappyAbsSyn
happyIn17 ()
x = HappyWrap17 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap17
HappyWrap17 ()
x)
{-# INLINE happyIn17 #-}
happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
happyOut17 :: HappyAbsSyn -> HappyWrap17
happyOut17 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap17
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut17 #-}
newtype HappyWrap18 = HappyWrap18 (())
happyIn18 :: (()) -> (HappyAbsSyn )
happyIn18 :: () -> HappyAbsSyn
happyIn18 ()
x = HappyWrap18 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap18
HappyWrap18 ()
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 ([Expr Position]))
happyIn19 :: (NonEmpty ([Expr Position])) -> (HappyAbsSyn )
happyIn19 :: NonEmpty [Expr Position] -> HappyAbsSyn
happyIn19 NonEmpty [Expr Position]
x = HappyWrap19 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (NonEmpty [Expr Position] -> HappyWrap19
HappyWrap19 NonEmpty [Expr 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 ((Position, Text)))
happyIn20 :: (NonEmpty ((Position, Text))) -> (HappyAbsSyn )
happyIn20 :: Key Position -> HappyAbsSyn
happyIn20 Key Position
x = HappyWrap20 -> HappyAbsSyn
forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Key Position -> HappyWrap20
HappyWrap20 Key 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 #-}
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 #-}


{-# NOINLINE happyTokenStrings #-}
happyTokenStrings :: [String]
happyTokenStrings = [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"]

happyActOffsets :: HappyAddr
happyActOffsets :: HappyAddr
happyActOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x6a\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x24\x00\x00\x00\x2a\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\xff\xff\x22\x00\x00\x00\x19\x00\x00\x00\x2a\x00\x00\x00\x6a\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xff\xff\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00"#

happyGotoOffsets :: HappyAddr
happyGotoOffsets :: HappyAddr
happyGotoOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x13\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\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\x4e\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xff\xff\x5f\x00\x00\x00\x57\x00\x00\x00\x6e\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x6f\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyDefActions :: HappyAddr
happyDefActions :: HappyAddr
happyDefActions = Addr# -> HappyAddr
HappyA# Addr#
"\xfd\xff\xff\xff\x00\x00\x00\x00\xd9\xff\xff\xff\xfc\xff\xff\xff\xde\xff\xff\xff\xd7\xff\xff\xff\xfe\xff\xff\xff\xf8\xff\xff\xff\xdb\xff\xff\xff\xda\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xff\xff\xf6\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xff\xff\x00\x00\x00\x00\xdc\xff\xff\xff\xd8\xff\xff\xff\xd6\xff\xff\xff\xfb\xff\xff\xff\xfa\xff\xff\xff\xde\xff\xff\xff\xf9\xff\xff\xff\xeb\xff\xff\xff\xec\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\xff\xff\xf1\xff\xff\xff\xf3\xff\xff\xff\xf5\xff\xff\xff\xf4\xff\xff\xff\xee\xff\xff\xff\xed\xff\xff\xff\xf0\xff\xff\xff\xef\xff\xff\xff\xe0\xff\xff\xff\xe0\xff\xff\xff\xde\xff\xff\xff\xe0\xff\xff\xff\xdc\xff\xff\xff\xe7\xff\xff\xff\x00\x00\x00\x00\xdf\xff\xff\xff\xdc\xff\xff\xff\xe0\xff\xff\xff\xdc\xff\xff\xff\x00\x00\x00\x00\xe5\xff\xff\xff\x00\x00\x00\x00\xe0\xff\xff\xff\xe2\xff\xff\xff\x00\x00\x00\x00\xe0\xff\xff\xff\xe8\xff\xff\xff\xdc\xff\xff\xff\xea\xff\xff\xff\xde\xff\xff\xff\xe4\xff\xff\xff\xe0\xff\xff\xff\x00\x00\x00\x00\xe6\xff\xff\xff\x00\x00\x00\x00\xe9\xff\xff\xff\xe3\xff\xff\xff\xe1\xff\xff\xff"#

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

happyTable :: HappyAddr
happyTable :: HappyAddr
happyTable = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x30\x00\x00\x00\x2b\x00\x00\x00\x13\x00\x00\x00\xdc\xff\xff\xff\x2c\x00\x00\x00\x3a\x00\x00\x00\xdd\xff\xff\xff\x30\x00\x00\x00\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x0e\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x18\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x12\x00\x00\x00\x07\x00\x00\x00\x19\x00\x00\x00\x09\x00\x00\x00\x2d\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x41\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x15\x00\x00\x00\x10\x00\x00\x00\x05\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x2e\x00\x00\x00\x2a\x00\x00\x00\x07\x00\x00\x00\x42\x00\x00\x00\x09\x00\x00\x00\x07\x00\x00\x00\x30\x00\x00\x00\x09\x00\x00\x00\x07\x00\x00\x00\x29\x00\x00\x00\x09\x00\x00\x00\x0f\x00\x00\x00\x05\x00\x00\x00\x37\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x3b\x00\x00\x00\x35\x00\x00\x00\x3d\x00\x00\x00\x3f\x00\x00\x00\x30\x00\x00\x00\x30\x00\x00\x00\x45\x00\x00\x00\x07\x00\x00\x00\xdd\xff\xff\xff\x09\x00\x00\x00\x16\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x31\x00\x00\x00\x1b\x00\x00\x00\x44\x00\x00\x00\x1c\x00\x00\x00\x32\x00\x00\x00\x13\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x33\x00\x00\x00\x3f\x00\x00\x00\x1b\x00\x00\x00\x19\x00\x00\x00\x1c\x00\x00\x00\x2a\x00\x00\x00\x38\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x40\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x0b\x00\x00\x00\x1c\x00\x00\x00\x0c\x00\x00\x00\x35\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x30\x00\x00\x00\x37\x00\x00\x00\x3d\x00\x00\x00\x3b\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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
41) [
        (Int
1 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_1),
        (Int
2 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_2),
        (Int
3 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_3),
        (Int
4 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_4),
        (Int
5 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_5),
        (Int
6 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_6),
        (Int
7 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_7),
        (Int
8 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_8),
        (Int
9 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_9),
        (Int
10 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_10),
        (Int
11 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_11),
        (Int
12 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_12),
        (Int
13 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_13),
        (Int
14 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_14),
        (Int
15 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_15),
        (Int
16 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_16),
        (Int
17 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_17),
        (Int
18 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_18),
        (Int
19 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_19),
        (Int
20 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_20),
        (Int
21 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_21),
        (Int
22 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_22),
        (Int
23 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_23),
        (Int
24 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_24),
        (Int
25 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_25),
        (Int
26 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_26),
        (Int
27 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_27),
        (Int
28 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_28),
        (Int
29 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_29),
        (Int
30 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_30),
        (Int
31 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_31),
        (Int
32 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_32),
        (Int
33 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_33),
        (Int
34 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_34),
        (Int
35 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_35),
        (Int
36 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_36),
        (Int
37 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_37),
        (Int
38 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_38),
        (Int
39 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_39),
        (Int
40 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_40),
        (Int
41 , Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_41)
        ]

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

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

happy_n_terms :: Int
happy_n_terms = Int
23 :: Happy_Prelude.Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
18 :: Happy_Prelude.Int

happy_n_starts :: Int
happy_n_starts = Int
1 :: Happy_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 -> HappyWrap19
happyOut19 HappyAbsSyn
happy_x_1 of { (HappyWrap19 NonEmpty [Expr Position]
happy_var_1) -> 
        [Expr Position] -> HappyAbsSyn
happyIn5
                 (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
happyIn6
                 ([]
        )

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 -> HappyWrap7
happyOut7 HappyAbsSyn
happy_x_1 of { (HappyWrap7 (Key Position, Val Position)
happy_var_1) -> 
        [Expr Position] -> HappyAbsSyn
happyIn6
                 ([(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 -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_2 of { (HappyWrap8 Key Position
happy_var_2) -> 
        [Expr Position] -> HappyAbsSyn
happyIn6
                 ([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 -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_2 of { (HappyWrap8 Key Position
happy_var_2) -> 
        [Expr Position] -> HappyAbsSyn
happyIn6
                 ([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 {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> 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 -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_1 of { (HappyWrap8 Key Position
happy_var_1) -> 
        case HappyAbsSyn -> HappyWrap10
happyOut10 HappyAbsSyn
happy_x_5 of { (HappyWrap10 Val Position
happy_var_5) -> 
        (Key Position, Val Position) -> HappyAbsSyn
happyIn7
                 ((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 -> HappyWrap20
happyOut20 HappyAbsSyn
happy_x_1 of { (HappyWrap20 Key Position
happy_var_1) -> 
        Key Position -> HappyAbsSyn
happyIn8
                 (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
happyIn9
                 ((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
happyIn9
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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
happyIn10
                 ((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 -> HappyWrap13
happyOut13 HappyAbsSyn
happy_x_1 of { (HappyWrap13 Located [Val Position]
happy_var_1) -> 
        Val Position -> HappyAbsSyn
happyIn10
                 ((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 -> HappyWrap11
happyOut11 HappyAbsSyn
happy_x_1 of { (HappyWrap11 Located [(Key Position, Val Position)]
happy_var_1) -> 
        Val Position -> HappyAbsSyn
happyIn10
                 ((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 {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
6# Int#
6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_21
happyReduction_21 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_21 (HappyAbsSyn
happy_x_6 `HappyStk`
        HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokCurlyO) -> 
        case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_3 of { (HappyWrap12 [(Key Position, Val Position)]
happy_var_3) -> 
        Located [(Key Position, Val Position)] -> HappyAbsSyn
happyIn11
                 (Position
-> [(Key Position, Val Position)]
-> Located [(Key Position, Val Position)]
forall a. Position -> a -> Located a
Located Position
happy_var_2 ([(Key Position, Val Position)] -> [(Key Position, Val Position)]
forall a. [a] -> [a]
reverse [(Key Position, Val Position)]
happy_var_3)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_22 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_22 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
8# Int#
6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22
happyReduction_22 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22 (HappyAbsSyn
happy_x_8 `HappyStk`
        HappyAbsSyn
happy_x_7 `HappyStk`
        HappyAbsSyn
happy_x_6 `HappyStk`
        HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokCurlyO) -> 
        case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_3 of { (HappyWrap12 [(Key Position, Val Position)]
happy_var_3) -> 
        Located [(Key Position, Val Position)] -> HappyAbsSyn
happyIn11
                 (Position
-> [(Key Position, Val Position)]
-> Located [(Key Position, Val Position)]
forall a. Position -> a -> Located a
Located Position
happy_var_2 ([(Key Position, Val Position)] -> [(Key Position, Val Position)]
forall a. [a] -> [a]
reverse [(Key Position, Val Position)]
happy_var_3)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_23 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_23 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
5# Int#
6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23
happyReduction_23 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_23 (HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokCurlyO) -> 
        Located [(Key Position, Val Position)] -> HappyAbsSyn
happyIn11
                 (Position
-> [(Key Position, Val Position)]
-> Located [(Key Position, Val Position)]
forall a. Position -> a -> Located a
Located Position
happy_var_2 []
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}

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

happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_25 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_25 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
5# Int#
7# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_25
happyReduction_25 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_25 (HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_1 of { (HappyWrap12 [(Key Position, Val Position)]
happy_var_1) -> 
        case HappyAbsSyn -> HappyWrap7
happyOut7 HappyAbsSyn
happy_x_5 of { (HappyWrap7 (Key Position, Val Position)
happy_var_5) -> 
        [(Key Position, Val Position)] -> HappyAbsSyn
happyIn12
                 ((Key Position, Val Position)
happy_var_5 (Key Position, Val Position)
-> [(Key Position, Val Position)] -> [(Key Position, Val Position)]
forall a. a -> [a] -> [a]
: [(Key Position, Val Position)]
happy_var_1
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_26 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_26 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
5# Int#
8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_26
happyReduction_26 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_26 (HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokSquareO) -> 
        Located [Val Position] -> HappyAbsSyn
happyIn13
                 (Position -> [Val Position] -> Located [Val Position]
forall a. Position -> a -> Located a
Located Position
happy_var_2 []
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}

happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_27 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_27 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
6# Int#
8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_27
happyReduction_27 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_27 (HappyAbsSyn
happy_x_6 `HappyStk`
        HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokSquareO) -> 
        case HappyAbsSyn -> HappyWrap14
happyOut14 HappyAbsSyn
happy_x_4 of { (HappyWrap14 [Val Position]
happy_var_4) -> 
        Located [Val Position] -> HappyAbsSyn
happyIn13
                 (Position -> [Val Position] -> Located [Val Position]
forall a. Position -> a -> Located a
Located Position
happy_var_2 ([Val Position] -> [Val Position]
forall a. [a] -> [a]
reverse [Val Position]
happy_var_4)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_28 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_28 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
8# Int#
8# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_28
happyReduction_28 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_28 (HappyAbsSyn
happy_x_8 `HappyStk`
        HappyAbsSyn
happy_x_7 `HappyStk`
        HappyAbsSyn
happy_x_6 `HappyStk`
        HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> Located Token
happyOutTok HappyAbsSyn
happy_x_2 of { (Located Position
happy_var_2 Token
TokSquareO) -> 
        case HappyAbsSyn -> HappyWrap14
happyOut14 HappyAbsSyn
happy_x_4 of { (HappyWrap14 [Val Position]
happy_var_4) -> 
        Located [Val Position] -> HappyAbsSyn
happyIn13
                 (Position -> [Val Position] -> Located [Val Position]
forall a. Position -> a -> Located a
Located Position
happy_var_2 ([Val Position] -> [Val Position]
forall a. [a] -> [a]
reverse [Val Position]
happy_var_4)
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

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

happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_30 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_30 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {r}.
Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
5# Int#
9# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_30
happyReduction_30 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_30 (HappyAbsSyn
happy_x_5 `HappyStk`
        HappyAbsSyn
happy_x_4 `HappyStk`
        HappyAbsSyn
happy_x_3 `HappyStk`
        HappyAbsSyn
happy_x_2 `HappyStk`
        HappyAbsSyn
happy_x_1 `HappyStk`
        HappyStk HappyAbsSyn
happyRest)
         = case HappyAbsSyn -> HappyWrap14
happyOut14 HappyAbsSyn
happy_x_1 of { (HappyWrap14 [Val Position]
happy_var_1) -> 
        case HappyAbsSyn -> HappyWrap10
happyOut10 HappyAbsSyn
happy_x_4 of { (HappyWrap10 Val Position
happy_var_4) -> 
        [Val Position] -> HappyAbsSyn
happyIn14
                 (Val Position
happy_var_4 Val Position -> [Val Position] -> [Val Position]
forall a. a -> [a] -> [a]
: [Val Position]
happy_var_1
        ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

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

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

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

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

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

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

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

happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_38 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_38 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happySpecReduce_1  Int#
16# HappyAbsSyn -> HappyAbsSyn
happyReduction_38
happyReduction_38 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_38 HappyAbsSyn
happy_x_1
         =  case HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
happy_x_1 of { (HappyWrap6 [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_39 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_39 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_39 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happySpecReduce_3  Int#
16# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_39
happyReduction_39 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_39 HappyAbsSyn
happy_x_3
        p
happy_x_2
        HappyAbsSyn
happy_x_1
         =  case HappyAbsSyn -> HappyWrap21
happyOut21 HappyAbsSyn
happy_x_1 of { (HappyWrap21 NonEmpty [Expr Position]
happy_var_1) -> 
        case HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
happy_x_3 of { (HappyWrap6 [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_40 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_40 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_40 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happySpecReduce_1  Int#
17# HappyAbsSyn -> HappyAbsSyn
happyReduction_40
happyReduction_40 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_40 HappyAbsSyn
happy_x_1
         =  case HappyAbsSyn -> HappyWrap9
happyOut9 HappyAbsSyn
happy_x_1 of { (HappyWrap9 (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_41 :: () => Happy_GHC_Exts.Int# -> Located Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser r (HappyAbsSyn )
happyReduce_41 :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyReduce_41 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happySpecReduce_3  Int#
17# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_41
happyReduction_41 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_41 HappyAbsSyn
happy_x_3
        p
happy_x_2
        HappyAbsSyn
happy_x_1
         =  case HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
happy_x_1 of { (HappyWrap22 Key Position
happy_var_1) -> 
        case HappyAbsSyn -> HappyWrap9
happyOut9 HappyAbsSyn
happy_x_3 of { (HappyWrap9 (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
        )}}

happyTerminalToTok :: Located Token -> Int#
happyTerminalToTok Located Token
term = case Located Token
term of {
        Located Position
_ Token
TokEOF -> Int#
22#;
        Located Position
happy_dollar_dollar Token
TokComma -> Int#
2#;
        Located Position
happy_dollar_dollar Token
TokEquals -> Int#
3#;
        Located Position
happy_dollar_dollar Token
TokNewline -> Int#
4#;
        Located Position
happy_dollar_dollar Token
TokPeriod -> Int#
5#;
        Located Position
happy_dollar_dollar Token
TokSquareO -> Int#
6#;
        Located Position
happy_dollar_dollar Token
TokSquareC -> Int#
7#;
        Located Position
happy_dollar_dollar Token
Tok2SquareO -> Int#
8#;
        Located Position
happy_dollar_dollar Token
Tok2SquareC -> Int#
9#;
        Located Position
happy_dollar_dollar Token
TokCurlyO -> Int#
10#;
        Located Position
happy_dollar_dollar Token
TokCurlyC -> 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
asBareKey        -> Just Located Text
happy_dollar_dollar) -> 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
asString         -> Just Located Text
happy_dollar_dollar) -> Int#
13#;
        ((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#
14#;
        ((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#
15#;
        ((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#
16#;
        ((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#
17#;
        ((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#
18#;
        ((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#
19#;
        ((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#
20#;
        ((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#
21#;
        Located Token
_ -> Int#
-1#;
        }
{-# NOINLINE happyTerminalToTok #-}

happyLex :: (Located Token -> Parser r a)
-> (Int# -> Located Token -> Parser r a) -> Parser r a
happyLex Located Token -> Parser r a
kend Int# -> Located Token -> Parser r a
kmore = (Located Token -> Parser r a) -> Parser r a
forall r a. (Located Token -> Parser r a) -> Parser r a
lexerP (\Located Token
tk -> case Located Token
tk of {
        Located Position
_ Token
TokEOF -> Located Token -> Parser r a
kend Located Token
tk;
        Located Token
_ -> Int# -> Located Token -> Parser r a
kmore (Located Token -> Int#
happyTerminalToTok Located Token
tk) Located Token
tk })
{-# INLINE happyLex #-}

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)
-> (Int# -> Located Token -> Parser r HappyAbsSyn)
-> Parser r HappyAbsSyn
forall {r} {a}.
(Located Token -> Parser r a)
-> (Int# -> Located Token -> Parser r a) -> Parser r a
happyLex (\Located Token
tk -> 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#
22# Located Token
tk Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk) (\Int#
i Located Token
tk -> 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)

happyReport :: Int# -> Located Token -> [String] -> Parser r a -> Parser r a
happyReport Int#
22# = Located Token -> [String] -> Parser r a -> Parser r a
forall r a. Located Token -> [String] -> Parser r a -> Parser r a
happyReport'
happyReport Int#
_ = Located Token -> [String] -> Parser r a -> Parser r a
forall r a. Located Token -> [String] -> Parser r a -> Parser r a
happyReport'


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)
happyDoParse :: () => 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 Happy_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
happyFmap1 :: (t -> b) -> Parser r t -> Parser r b
happyFmap1 t -> b
f Parser r t
m = Parser r t -> (t -> Parser r b) -> Parser r b
forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
happyThen Parser r t
m (\t
a -> b -> Parser r b
forall a r. a -> Parser r a
happyReturn (t -> b
f t
a))
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
happyReport' :: () => (Located Token) -> [Happy_Prelude.String] -> (Parser r a) -> (Parser r a)
happyReport' :: forall r a. Located Token -> [String] -> Parser r a -> Parser r a
happyReport' = (\Located Token
tokens [String]
expected Parser r a
resume -> (forall r a. Located Token -> Parser r a
errorP) Located Token
tokens)

happyAbort :: () => (Parser r a)
happyAbort :: forall r a. Parser r a
happyAbort = String -> Parser r a
forall a. HasCallStack => String -> a
Happy_Prelude.error String
"Called abort handler in non-resumptive parser"

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
happyDoParse Int#
0#) (\HappyAbsSyn
x -> [Expr Position] -> Parser r [Expr Position]
forall a r. a -> Parser r a
happyReturn (let {(HappyWrap5 [Expr Position]
x') = HappyAbsSyn -> HappyWrap5
happyOut5 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
#define HAPPY_COERCE 1
-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $

#if !defined(__GLASGOW_HASKELL__)
#  error This code isn't being built with GHC.
#endif

-- Get WORDS_BIGENDIAN (if defined)
#include "MachDeps.h"

-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Happy_Prelude.Bool)
#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Happy_Prelude.Bool)
#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Happy_Prelude.Bool)
#define PLUS(n,m) (n Happy_GHC_Exts.+# m)
#define MINUS(n,m) (n Happy_GHC_Exts.-# m)
#define TIMES(n,m) (n Happy_GHC_Exts.*# m)
#define NEGATE(n) (Happy_GHC_Exts.negateInt# (n))

type Happy_Int = Happy_GHC_Exts.Int#
data Happy_IntList = HappyCons Happy_Int Happy_IntList

#define INVALID_TOK -1#
#define ERROR_TOK 0#
#define CATCH_TOK 1#

#if defined(HAPPY_COERCE)
#  define GET_ERROR_TOKEN(x)  (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# i) -> i })
#  define MK_ERROR_TOKEN(i)   (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# i))
#  define MK_TOKEN(x)         (happyInTok (x))
#else
#  define GET_ERROR_TOKEN(x)  (case x of { HappyErrorToken (Happy_GHC_Exts.I# i) -> i })
#  define MK_ERROR_TOKEN(i)   (HappyErrorToken (Happy_GHC_Exts.I# i))
#  define MK_TOKEN(x)         (HappyTerminal (x))
#endif

#if defined(HAPPY_DEBUG)
#  define DEBUG_TRACE(s)    (happyTrace (s)) Happy_Prelude.$
happyTrace string expr = Happy_System_IO_Unsafe.unsafePerformIO Happy_Prelude.$ do
    Happy_System_IO.hPutStr Happy_System_IO.stderr string
    Happy_Prelude.return expr
#else
#  define DEBUG_TRACE(s)    {- nothing -}
#endif

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

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

happyDoParse :: forall r. Int# -> Parser r HappyAbsSyn
happyDoParse Int#
start_state = Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
forall r.
Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
happyNewToken Int#
start_state Happy_IntList
forall a. a
notHappyAtAll HappyStk HappyAbsSyn
forall a. a
notHappyAtAll

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

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

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

happyDoAction :: forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyDoAction Int#
i Located Token
tk Int#
st =
  DEBUG_TRACE("state: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++
              ",\ttoken: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++
              ",\taction: ")
  case Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st) of
    HappyAction
HappyFail             -> DEBUG_TRACE("failing.\n")
                             Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyFail Int#
i Located Token
tk Int#
st
    HappyAction
HappyAccept           -> DEBUG_TRACE("accept.\n")
                             Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {p} {p} {a} {r}.
Int# -> p -> Int# -> p -> HappyStk a -> Parser r a
happyAccept Int#
i Located Token
tk Int#
st
    HappyReduce Int#
rule      -> DEBUG_TRACE("reduce (rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# rule) Happy_Prelude.++ ")")
                             (Array
  Int
  (Int#
   -> Located Token
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> Parser r HappyAbsSyn)
forall r.
Array
  Int
  (Int#
   -> Located Token
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> Parser r HappyAbsSyn)
happyReduceArr Array
  Int
  (Int#
   -> Located Token
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> Parser r HappyAbsSyn)
-> Int
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall i e. Ix i => Array i e -> i -> e
Happy_Data_Array.! (Int# -> Int
Happy_GHC_Exts.I# Int#
rule)) Int#
i Located Token
tk Int#
st
    HappyShift  Int#
new_state -> DEBUG_TRACE("shift, enter state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
                             Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyShift Int#
new_state Int#
i Located Token
tk Int#
st

{-# INLINE happyNextAction #-}
happyNextAction :: Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st = case Int# -> Int# -> Maybe Int
happyIndexActionTable Int#
i Int#
st of
  Happy_Prelude.Just (Happy_GHC_Exts.I# Int#
act) -> Int#
act
  Maybe Int
Happy_Prelude.Nothing                      -> HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyDefActions Int#
st

{-# INLINE happyIndexActionTable #-}
happyIndexActionTable :: Int# -> Int# -> Maybe Int
happyIndexActionTable Int#
i Int#
st
  | GTE(i, 0#), GTE(off, 0#), EQ(happyIndexOffAddr happyCheck off, i)
  -- i >= 0:   Guard against INVALID_TOK (do the default action, which ultimately errors)
  -- off >= 0: Otherwise it's a default action
  -- equality check: Ensure that the entry in the compressed array is owned by st
  = Int -> Maybe Int
forall a. a -> Maybe a
Happy_Prelude.Just (Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off))
  | Bool
Happy_Prelude.otherwise
  = Maybe Int
forall a. Maybe a
Happy_Prelude.Nothing
  where
    off :: Int#
off = PLUS(happyIndexOffAddr happyActOffsets st, i)

data HappyAction
  = HappyFail
  | HappyAccept
  | HappyReduce Happy_Int -- rule number
  | HappyShift Happy_Int  -- new state
  deriving Int -> HappyAction -> ShowS
[HappyAction] -> ShowS
HappyAction -> String
(Int -> HappyAction -> ShowS)
-> (HappyAction -> String)
-> ([HappyAction] -> ShowS)
-> Show HappyAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HappyAction -> ShowS
showsPrec :: Int -> HappyAction -> ShowS
$cshow :: HappyAction -> String
show :: HappyAction -> String
$cshowList :: [HappyAction] -> ShowS
showList :: [HappyAction] -> ShowS
Happy_Prelude.Show

{-# INLINE happyDecodeAction #-}
happyDecodeAction :: Happy_Int -> HappyAction
happyDecodeAction :: Int# -> HappyAction
happyDecodeAction  Int#
0#                        = HappyAction
HappyFail
happyDecodeAction Int#
-1#                        = HappyAction
HappyAccept
happyDecodeAction Int#
action | LT(action, 0#)    = HappyReduce NEGATE(PLUS(action, 1#))
                         | Bool
Happy_Prelude.otherwise = Int# -> HappyAction
HappyShift MINUS(action, 1#)

{-# INLINE happyIndexGotoTable #-}
happyIndexGotoTable :: Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off
  where
    off :: Int#
off = PLUS(happyIndexOffAddr happyGotoOffsets st, nt)

{-# INLINE happyIndexOffAddr #-}
happyIndexOffAddr :: HappyAddr -> Happy_Int -> Happy_Int
happyIndexOffAddr :: HappyAddr -> Int# -> Int#
happyIndexOffAddr (HappyA# Addr#
arr) Int#
off =
#if __GLASGOW_HASKELL__ >= 901
  Int32# -> Int#
Happy_GHC_Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
#endif
#ifdef WORDS_BIGENDIAN
  -- The CI of `alex` tests this code path
  (Happy_GHC_Exts.word32ToInt32# (Happy_GHC_Exts.wordToWord32# (Happy_GHC_Exts.byteSwap32# (Happy_GHC_Exts.word32ToWord# (Happy_GHC_Exts.int32ToWord32#
#endif
  (Addr# -> Int# -> Int32#
Happy_GHC_Exts.indexInt32OffAddr# Addr#
arr Int#
off)
#ifdef WORDS_BIGENDIAN
  )))))
#endif

happyIndexRuleArr :: Happy_Int -> (# Happy_Int, Happy_Int #)
happyIndexRuleArr :: Int# -> (# Int#, Int# #)
happyIndexRuleArr Int#
r = (# Int#
nt, Int#
len #)
  where
    !(Happy_GHC_Exts.I# Int#
n_starts) = Int
happy_n_starts
    offs :: Int#
offs = TIMES(MINUS(r,n_starts),2#)
    nt :: Int#
nt = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyRuleArr Int#
offs
    len :: Int#
len = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyRuleArr PLUS(offs,1#)

data HappyAddr = HappyA# Happy_GHC_Exts.Addr#

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

happyShift :: Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyShift Int#
new_state ERROR_TOK tk st sts stk@(x `HappyStk` _) =
     -- See "Error Fixup" below
     let i = GET_ERROR_TOKEN(x) in
     DEBUG_TRACE("shifting the error token")
     happyDoAction i tk new_state (HappyCons st sts) stk

happyShift Int#
new_state Int#
i Located Token
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
     Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
forall r.
Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
happyNewToken Int#
new_state (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) (MK_TOKEN(tk) `HappyStk` stk)

-- happyReduce is specialised for the common cases.

happySpecReduce_0 :: Int#
-> HappyAbsSyn
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happySpecReduce_0 Int#
nt HappyAbsSyn
fn Int#
j Located Token
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
     = HappyAbsSyn -> Parser r HappyAbsSyn -> Parser r HappyAbsSyn
forall a b. a -> b -> b
happySeq HappyAbsSyn
fn (Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyGoto Int#
nt Int#
j Located Token
tk Int#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) (HappyAbsSyn
fn HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
stk))

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

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

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

happyReduce :: Int#
-> Int#
-> (p -> HappyStk HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> p
-> Parser r HappyAbsSyn
happyReduce Int#
k Int#
nt p -> HappyStk HappyAbsSyn
fn Int#
j Located Token
tk Int#
st Happy_IntList
sts p
stk
     = case Int# -> Happy_IntList -> Happy_IntList
happyDrop MINUS(k,(1# :: Happy_Int)) sts of
         sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
                let r :: HappyStk HappyAbsSyn
r = p -> HappyStk HappyAbsSyn
fn p
stk in -- it doesn't hurt to always seq here...
                Int#
st Int# -> Parser r HappyAbsSyn -> Parser r HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn -> Parser r HappyAbsSyn
forall a b. a -> b -> b
happyDoSeq HappyStk HappyAbsSyn
r (Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyGoto Int#
nt Int#
j Located Token
tk Int#
st1 Happy_IntList
sts1 HappyStk HappyAbsSyn
r)

happyMonadReduce :: Int#
-> Int#
-> (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn)
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyMonadReduce Int#
k Int#
nt HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
fn Int#
j Located Token
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
      case Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
k (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) of
        sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
          let drop_stk :: HappyStk HappyAbsSyn
drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk HappyAbsSyn
stk in
          Int#
j Int# -> Parser r HappyAbsSyn -> Parser r HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` Parser r HappyAbsSyn
-> (HappyAbsSyn -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
happyThen1 (HappyStk HappyAbsSyn -> Located Token -> Parser r HappyAbsSyn
fn HappyStk HappyAbsSyn
stk Located Token
tk)
                                     (\HappyAbsSyn
r -> Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyGoto Int#
nt Int#
j Located Token
tk Int#
st1 Happy_IntList
sts1 (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
drop_stk))

happyMonad2Reduce :: Int#
-> Int#
-> (HappyStk HappyAbsSyn -> t -> Parser r HappyAbsSyn)
-> Int#
-> t
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyMonad2Reduce Int#
k Int#
nt HappyStk HappyAbsSyn -> t -> Parser r HappyAbsSyn
fn Int#
j t
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk =
      case Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
k (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts) of
        sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_) ->
          let drop_stk :: HappyStk HappyAbsSyn
drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall {a}. Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
k HappyStk HappyAbsSyn
stk
              off :: Int#
off = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyGotoOffsets Int#
st1
              off_i :: Int#
off_i = PLUS(off, nt)
              new_state :: Int#
new_state = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off_i
          in
            Int#
j Int# -> Parser r HappyAbsSyn -> Parser r HappyAbsSyn
forall a. Int# -> a -> a
`happyTcHack` Parser r HappyAbsSyn
-> (HappyAbsSyn -> Parser r HappyAbsSyn) -> Parser r HappyAbsSyn
forall r a b. Parser r a -> (a -> Parser r b) -> Parser r b
happyThen1 (HappyStk HappyAbsSyn -> t -> Parser r HappyAbsSyn
fn HappyStk HappyAbsSyn
stk t
tk)
                                       (\HappyAbsSyn
r -> Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
forall r.
Int#
-> Happy_IntList -> HappyStk HappyAbsSyn -> Parser r HappyAbsSyn
happyNewToken Int#
new_state Happy_IntList
sts1 (HappyAbsSyn
r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
drop_stk))

happyDrop :: Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
0# Happy_IntList
l               = Happy_IntList
l
happyDrop Int#
n  (HappyCons Int#
_ Happy_IntList
t) = Int# -> Happy_IntList -> Happy_IntList
happyDrop MINUS(n,(1# :: Happy_Int)) t

happyDropStk :: Int# -> HappyStk a -> HappyStk a
happyDropStk Int#
0# HappyStk a
l                 = HappyStk a
l
happyDropStk Int#
n  (a
x `HappyStk` HappyStk a
xs) = Int# -> HappyStk a -> HappyStk a
happyDropStk MINUS(n,(1#::Happy_Int)) xs

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

happyGoto :: Int#
-> Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyGoto Int#
nt Int#
j Located Token
tk Int#
st =
   DEBUG_TRACE(", goto state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
   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#
j Located Token
tk Int#
new_state
  where new_state :: Int#
new_state = Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st

{- Note [Error recovery]
~~~~~~~~~~~~~~~~~~~~~~~~
When there is no applicable action for the current lookahead token `tk`,
happy enters error recovery mode. Depending on whether the grammar file
declares the two action form `%error { abort } { report }` for
    Resumptive Error Handling,
it works in one (not resumptive) or two phases (resumptive):

 1. Fixup mode:
    Try to see if there is an action for the error token ERROR_TOK. If there
    is, do *not* emit an error and pretend instead that an `error` token was
    inserted.
    When there is no ERROR_TOK action, report an error.

    In non-resumptive error handling, calling the single error handler
    (e.g. `happyError`) will throw an exception and abort the parser.
    However, in resumptive error handling we enter *error resumption mode*.

 2. Error resumption mode:
    After reporting the error (with `report`), happy will attempt to find
    a good state stack to resume parsing in.
    For each candidate stack, it discards input until one of the candidates
    resumes (i.e. shifts the current input).
    If no candidate resumes before the end of input, resumption failed and
    calls the `abort` function, to much the same effect as in non-resumptive
    error handling.

    Candidate stacks are declared by the grammar author using the special
    `catch` terminal and called "catch frames".
    This mechanism is described in detail in Note [happyResume].

The `catch` resumption mechanism (2) is what usually is associated with
`error` in `bison` or `menhir`. Since `error` is used for the Fixup mechanism
(1) above, we call the corresponding token `catch`.
Furthermore, in constrast to `bison`, our implementation of `catch`
non-deterministically considers multiple catch frames on the stack for
resumption (See Note [Multiple catch frames]).

Note [happyResume]
~~~~~~~~~~~~~~~~~~
`happyResume` implements the resumption mechanism from Note [Error recovery].
It is best understood by example. Consider

Exp :: { String }
Exp : '1'                { "1" }
    | catch              { "catch" }
    | Exp '+' Exp %shift { $1 Happy_Prelude.++ " + " Happy_Prelude.++ $3 } -- %shift: associate 1 + 1 + 1 to the right
    | '(' Exp ')'        { "(" Happy_Prelude.++ $2 Happy_Prelude.++ ")" }

The idea of the use of `catch` here is that upon encountering a parse error
during expression parsing, we can gracefully degrade using the `catch` rule,
still producing a partial syntax tree and keep on parsing to find further
syntax errors.

Let's trace the parser state for input 11+1, which will error out after shifting 1.
After shifting, we have the following item stack (growing downwards and omitting
transitive closure items):

  State 0: %start_parseExp -> . Exp
  State 5: Exp -> '1' .

(Stack as a list of state numbers: [5,0].)
As Note [Error recovery] describes, we will first try Fixup mode.
That fails because no production can shift the `error` token.
Next we try Error resumption mode. This works as follows:

  1. Pop off the item stack until we find an item that can shift the `catch`
     token. (Implemented in `pop_items`.)
       * State 5 cannot shift catch. Pop.
       * State 0 can shift catch, which would transition into
          State 4: Exp -> catch .
     So record the *stack* `[4,0]` after doing the shift transition.
     We call this a *catch frame*, where the top is a *catch state*,
     corresponding to an item in which we just shifted a `catch` token.
     There can be multiple such catch stacks, see Note [Multiple catch frames].

  2. Discard tokens from the input until the lookahead can be shifted in one
     of the catch stacks. (Implemented in `discard_input_until_exp` and
     `some_catch_state_shifts`.)
       * We cannot shift the current lookahead '1' in state 4, so we discard
       * We *can* shift the next lookahead '+' in state 4, but only after
         reducing, which pops State 4 and goes to State 3:
           State 3: %start_parseExp -> Exp .
                    Exp -> Exp . '+' Exp
         Here we can shift '+'.
     As you can see, to implement this machinery we need to simulate
     the operation of the LALR automaton, especially reduction
     (`happySimulateReduce`).

Note [Multiple catch frames]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For fewer spurious error messages, it can be beneficial to trace multiple catch
items. Consider

Exp : '1'
    | catch
    | Exp '+' Exp %shift
    | '(' Exp ')'

Let's trace the parser state for input (;+1, which will error out after shifting (.
After shifting, we have the following item stack (growing downwards):

  State 0: %start_parseExp -> . Exp
  State 6: Exp -> '(' . Exp ')'

Upon error, we want to find items in the stack which can shift a catch token.
Note that both State 0 and State 6 can shift a catch token, transitioning into
  State 4: Exp -> catch .
Hence we record the catch frames `[4,6,0]` and `[4,0]` for possible resumption.

Which catch frame do we pick for resumption?
Note that resuming catch frame `[4,0]` will parse as "catch+1", whereas
resuming the innermost frame `[4,6,0]` corresponds to parsing "(catch+1".
The latter would keep discarding input until the closing ')' is found.
So we will discard + and 1, leading to a spurious syntax error at the end of
input, aborting the parse and never producing a partial syntax tree. Bad!

It is far preferable to resume with catch frame `[4,0]`, where we can resume
successfully on input +, so that is what we do.

In general, we pick the catch frame for resumption that discards the least
amount of input for a successful shift, preferring the topmost such catch frame.
-}

-- happyFail :: Happy_Int -> Token -> Happy_Int -> _
-- This function triggers Note [Error recovery].
-- If the current token is ERROR_TOK, phase (1) has failed and we might try
-- phase (2).
happyFail :: Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyFail ERROR_TOK = happyFixupFailed
happyFail 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
happyTryFixup Int#
i

-- Enter Error Fixup (see Note [Error recovery]):
-- generate an error token, save the old token and carry on.
-- When a `happyShift` accepts the error token, we will pop off the error token
-- to resume parsing with the current lookahead `i`.
happyTryFixup :: Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyTryFixup Int#
i Located Token
tk Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk =
  DEBUG_TRACE("entering `error` fixup.\n")
  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 ERROR_TOK tk action sts (MK_ERROR_TOKEN(i) `HappyStk` stk)
  -- NB: `happyShift` will simply pop the error token and carry on with
  --     `tk`. Hence we don't change `tk` in the call here

-- See Note [Error recovery], phase (2).
-- Enter resumption mode after reporting the error by calling `happyResume`.
happyFixupFailed :: Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyFixupFailed Located Token
tk Int#
st Happy_IntList
sts (HappyAbsSyn
x `HappyStk` HappyStk HappyAbsSyn
stk) =
  let i :: Int#
i = GET_ERROR_TOKEN(x) in
  DEBUG_TRACE("`error` fixup failed.\n")
  let resume :: Parser r HappyAbsSyn
resume   = Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall r.
Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyResume Int#
i Located Token
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
      expected :: [String]
expected = Int# -> Happy_IntList -> [String]
happyExpectedTokens Int#
st Happy_IntList
sts in
  Int#
-> Located Token
-> [String]
-> Parser r HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r} {a}.
Int# -> Located Token -> [String] -> Parser r a -> Parser r a
happyReport Int#
i Located Token
tk [String]
expected Parser r HappyAbsSyn
forall {r}. Parser r HappyAbsSyn
resume

-- happyResume :: Happy_Int -> Token -> Happy_Int -> _
-- See Note [happyResume]
happyResume :: Int#
-> Located Token
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
happyResume Int#
i Located Token
tk Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk = [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
forall {r}.
[(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
pop_items [] Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
  where
    !(Happy_GHC_Exts.I# Int#
n_starts) = Int
happy_n_starts   -- this is to test whether we have a start token
    !(Happy_GHC_Exts.I# Int#
eof_i) = Int
happy_n_terms Int -> Int -> Int
forall a. Num a => a -> a -> a
Happy_Prelude.- Int
1   -- this is the token number of the EOF token
    happy_list_to_list :: Happy_IntList -> [Happy_Prelude.Int]
    happy_list_to_list :: Happy_IntList -> [Int]
happy_list_to_list (HappyCons Int#
st Happy_IntList
sts)
      | LT(st, n_starts)
      = [(Int# -> Int
Happy_GHC_Exts.I# Int#
st)]
      | Bool
Happy_Prelude.otherwise
      = (Int# -> Int
Happy_GHC_Exts.I# Int#
st) Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Happy_IntList -> [Int]
happy_list_to_list Happy_IntList
sts

    -- See (1) of Note [happyResume]
    pop_items :: [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames Int#
st Happy_IntList
sts HappyStk HappyAbsSyn
stk
      | LT(st, n_starts)
      = DEBUG_TRACE("reached start state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", ")
        if [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new
          then DEBUG_TRACE("no resumption.\n")
               Parser r HappyAbsSyn
forall r a. Parser r a
happyAbort
          else DEBUG_TRACE("now discard input, trying to anchor in states " Happy_Prelude.++ Happy_Prelude.show (Happy_Prelude.map (happy_list_to_list . Happy_Prelude.fst) (Happy_Prelude.reverse catch_frames_new)) Happy_Prelude.++ ".\n")
               Int#
-> Located Token
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Parser r HappyAbsSyn
forall {r}.
Int#
-> Located Token
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Parser r HappyAbsSyn
discard_input_until_exp Int#
i Located Token
tk ([(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
forall a. [a] -> [a]
Happy_Prelude.reverse [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new)
      | (HappyCons Int#
st1 Happy_IntList
sts1) <- Happy_IntList
sts, HappyAbsSyn
_ `HappyStk` HappyStk HappyAbsSyn
stk1 <- HappyStk HappyAbsSyn
stk
      = [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> Parser r HappyAbsSyn
pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new Int#
st1 Happy_IntList
sts1 HappyStk HappyAbsSyn
stk1
      where
        !catch_frames_new :: [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames_new
          | HappyShift Int#
new_state <- Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction CATCH_TOK st)
          , DEBUG_TRACE("can shift catch token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", into state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
            [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
Happy_Prelude.null (((Happy_IntList, HappyStk HappyAbsSyn) -> Bool)
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
forall a. (a -> Bool) -> [a] -> [a]
Happy_Prelude.filter (\(HappyCons Int#
_ (HappyCons Int#
h Happy_IntList
_),HappyStk HappyAbsSyn
_) -> EQ(st,h)) catch_frames)
          = (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
new_state (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts), MK_ERROR_TOKEN(i) `HappyStk` stk):catch_frames -- MK_ERROR_TOKEN(i) is just some dummy that should not be accessed by user code
          | Bool
Happy_Prelude.otherwise
          = DEBUG_TRACE("already shifted or can't shift catch in " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ "\n")
            [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames

    -- See (2) of Note [happyResume]
    discard_input_until_exp :: Int#
-> Located Token
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Parser r HappyAbsSyn
discard_input_until_exp Int#
i Located Token
tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames
      | Happy_Prelude.Just (HappyCons Int#
st (HappyCons Int#
catch_st Happy_IntList
sts), HappyStk HappyAbsSyn
catch_frame) <- Int#
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Maybe (Happy_IntList, HappyStk HappyAbsSyn)
forall {b}.
Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
some_catch_state_shifts Int#
i [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames
      = DEBUG_TRACE("found expected token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ " after shifting from " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# catch_st) Happy_Prelude.++ ": " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
        Int#
-> 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#
st (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
catch_st Happy_IntList
sts) HappyStk HappyAbsSyn
catch_frame
      | EQ(i,eof_i) -- is i EOF?
      = DEBUG_TRACE("reached EOF, cannot resume. abort parse :(\n")
        Parser r HappyAbsSyn
forall r a. Parser r a
happyAbort
      | Bool
Happy_Prelude.otherwise
      = DEBUG_TRACE("discard token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
        (Located Token -> Parser r HappyAbsSyn)
-> (Int# -> Located Token -> Parser r HappyAbsSyn)
-> Parser r HappyAbsSyn
forall {r} {a}.
(Located Token -> Parser r a)
-> (Int# -> Located Token -> Parser r a) -> Parser r a
happyLex (\Located Token
eof_tk -> Int#
-> Located Token
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Parser r HappyAbsSyn
discard_input_until_exp Int#
eof_i Located Token
eof_tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames) -- eof
                 (\Int#
i Located Token
tk   -> Int#
-> Located Token
-> [(Happy_IntList, HappyStk HappyAbsSyn)]
-> Parser r HappyAbsSyn
discard_input_until_exp Int#
i Located Token
tk [(Happy_IntList, HappyStk HappyAbsSyn)]
catch_frames)         -- not eof

    some_catch_state_shifts :: Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
some_catch_state_shifts Int#
_ [] = DEBUG_TRACE("no catch state could shift.\n") Happy_Prelude.Nothing
    some_catch_state_shifts Int#
i catch_frames :: [(Happy_IntList, b)]
catch_frames@(((HappyCons Int#
st Happy_IntList
sts),b
_):[(Happy_IntList, b)]
_) = Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st Happy_IntList
sts [(Happy_IntList, b)]
catch_frames
      where
        try_head :: Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st Happy_IntList
sts [(Happy_IntList, b)]
catch_frames = -- PRECONDITION: head catch_frames = (HappyCons st sts)
          DEBUG_TRACE("trying token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ " in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ": ")
          case Int# -> HappyAction
happyDecodeAction (Int# -> Int# -> Int#
happyNextAction Int#
i Int#
st) of
            HappyAction
HappyFail     -> DEBUG_TRACE("fail.\n")   some_catch_state_shifts i (Happy_Prelude.tail catch_frames)
            HappyAction
HappyAccept   -> DEBUG_TRACE("accept.\n") Happy_Prelude.Just (Happy_Prelude.head catch_frames)
            HappyShift Int#
_  -> DEBUG_TRACE("shift.\n")  Happy_Prelude.Just (Happy_Prelude.head catch_frames)
            HappyReduce Int#
r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts of
              (HappyCons Int#
st1 Happy_IntList
sts1) -> Int#
-> Int#
-> Happy_IntList
-> [(Happy_IntList, b)]
-> Maybe (Happy_IntList, b)
try_head Int#
i Int#
st1 Happy_IntList
sts1 [(Happy_IntList, b)]
catch_frames

happySimulateReduce :: Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts =
  DEBUG_TRACE("simulate reduction of rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# r) Happy_Prelude.++ ", ")
  let (# Int#
nt, Int#
len #) = Int# -> (# Int#, Int# #)
happyIndexRuleArr Int#
r in
  DEBUG_TRACE("nt " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# nt) Happy_Prelude.++ ", len: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# len) Happy_Prelude.++ ", new_st ")
  let !(sts1 :: Happy_IntList
sts1@(HappyCons Int#
st1 Happy_IntList
_)) = Int# -> Happy_IntList -> Happy_IntList
happyDrop Int#
len (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
st Happy_IntList
sts)
      new_st :: Int#
new_st = Int# -> Int# -> Int#
happyIndexGotoTable Int#
nt Int#
st1 in
  DEBUG_TRACE(Happy_Prelude.show (Happy_GHC_Exts.I# new_st) Happy_Prelude.++ ".\n")
  (Int# -> Happy_IntList -> Happy_IntList
HappyCons Int#
new_st Happy_IntList
sts1)

happyTokenToString :: Happy_Prelude.Int -> Happy_Prelude.String
happyTokenToString :: Int -> String
happyTokenToString Int
i = [String]
happyTokenStrings [String] -> Int -> String
forall a. HasCallStack => [a] -> Int -> a
Happy_Prelude.!! (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
Happy_Prelude.- Int
2) -- 2: errorTok, catchTok

happyExpectedTokens :: Happy_Int -> Happy_IntList -> [Happy_Prelude.String]
-- Upon a parse error, we want to suggest tokens that are expected in that
-- situation. This function computes such tokens.
-- It works by examining the top of the state stack.
-- For every token number that does a shift transition, record that token number.
-- For every token number that does a reduce transition, simulate that reduction
-- on the state state stack and repeat.
-- The recorded token numbers are then formatted with 'happyTokenToString' and
-- returned.
happyExpectedTokens :: Int# -> Happy_IntList -> [String]
happyExpectedTokens Int#
st Happy_IntList
sts =
  DEBUG_TRACE("constructing expected tokens.\n")
  (Int -> String) -> [Int] -> [String]
forall a b. (a -> b) -> [a] -> [b]
Happy_Prelude.map Int -> String
happyTokenToString (Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st Happy_IntList
sts [])
  where
    search_shifts :: Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st Happy_IntList
sts [Int]
shifts = ((Int, Int) -> [Int] -> [Int]) -> [Int] -> [(Int, Int)] -> [Int]
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Happy_Prelude.foldr (Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
add_action Int#
st Happy_IntList
sts) [Int]
shifts (Int# -> [(Int, Int)]
distinct_actions Int#
st)
    add_action :: Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
add_action Int#
st Happy_IntList
sts (Happy_GHC_Exts.I# Int#
i, Happy_GHC_Exts.I# Int#
act) [Int]
shifts =
      DEBUG_TRACE("found action in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", input " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ ", " Happy_Prelude.++ Happy_Prelude.show (happyDecodeAction act) Happy_Prelude.++ "\n")
      case Int# -> HappyAction
happyDecodeAction Int#
act of
        HappyAction
HappyFail     -> [Int]
shifts
        HappyAction
HappyAccept   -> [Int]
shifts -- This would always be %eof or error... Not helpful
        HappyShift Int#
_  -> Int -> [Int] -> [Int]
forall a. Ord a => a -> [a] -> [a]
Happy_Prelude.insert (Int# -> Int
Happy_GHC_Exts.I# Int#
i) [Int]
shifts
        HappyReduce Int#
r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
happySimulateReduce Int#
r Int#
st Happy_IntList
sts of
          (HappyCons Int#
st1 Happy_IntList
sts1) -> Int# -> Happy_IntList -> [Int] -> [Int]
search_shifts Int#
st1 Happy_IntList
sts1 [Int]
shifts
    distinct_actions :: Int# -> [(Int, Int)]
distinct_actions Int#
st
      -- The (token number, action) pairs of all actions in the given state
      = ((-Int
1), (Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyDefActions Int#
st)))
      (Int, Int) -> [(Int, Int)] -> [(Int, Int)]
forall a. a -> [a] -> [a]
: [ (Int
i, Int
act) | Int
i <- [Int
begin_i..Int
happy_n_terms], Int
act <- Int# -> Int -> [Int]
get_act Int#
row_off Int
i ]
      where
        row_off :: Int#
row_off = HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyActOffsets Int#
st
        begin_i :: Int
begin_i = Int
2 -- +2: errorTok,catchTok
    get_act :: Int# -> Int -> [Int]
get_act Int#
off (Happy_GHC_Exts.I# Int#
i) -- happyIndexActionTable with cached row offset
      | let off_i :: Int#
off_i = PLUS(off,i)
      , GTE(off_i,0#)
      , EQ(happyIndexOffAddr happyCheck off_i,i)
      = [(Int# -> Int
Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
happyIndexOffAddr HappyAddr
happyTable Int#
off_i))]
      | Bool
Happy_Prelude.otherwise
      = []

-- Internal happy errors:

notHappyAtAll :: a
notHappyAtAll :: forall a. a
notHappyAtAll = String -> a
forall a. HasCallStack => String -> a
Happy_Prelude.error String
"Internal Happy parser panic. This is not supposed to happen! Please open a bug report at https://github.com/haskell/happy/issues.\n"

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

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

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

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

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

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

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

-- end of Happy Template.