content: -- Notices:
  --
  -- Copyright 2020 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All Rights Reserved.
   
  -- Disclaimers
  -- No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE.  FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS."
   
  -- Waiver and Indemnity:  RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT.  IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.  RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.
  	
  	
  {-# OPTIONS_GHC -w #-}
  {-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
  module Parser.ParDecisionPaths where
  import Parser.LexDecisionPaths
  import Common.DecisionPath
  import AbsRawPVSLang (Id(..))
  import ErrM
  import qualified Data.Array as Happy_Data_Array
  import qualified Data.Bits as Bits
  import Control.Applicative(Applicative(..))
  import Control.Monad (ap)
  
  -- parser produced by Happy Version 1.19.9
  
  data HappyAbsSyn 
  	= HappyTerminal (Token)
  	| HappyErrorToken Int
  	| HappyAbsSyn4 (Integer)
  	| HappyAbsSyn5 (Id)
  	| HappyAbsSyn7 ([Integer])
  	| HappyAbsSyn8 (LDecisionPath)
  	| HappyAbsSyn9 ([LDecisionPath])
  	| HappyAbsSyn11 ([Id])
  	| HappyAbsSyn12 ((String, [LDecisionPath]))
  	| HappyAbsSyn13 ([(String, [LDecisionPath])])
  	| HappyAbsSyn14 (TargetDPs)
  
  {- to allow type-synonyms as our monads (likely
   - with explicitly-specified bind and return)
   - in Haskell98, it seems that with
   - /type M a = .../, then /(HappyReduction M)/
   - is not allowed.  But Happy is a
   - code-generator that can just substitute it.
  type HappyReduction m = 
  	   Int 
  	-> (Token)
  	-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> m HappyAbsSyn)
  	-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> m HappyAbsSyn)] 
  	-> HappyStk HappyAbsSyn 
  	-> [(Token)] -> m HappyAbsSyn
  -}
  
  action_0,
   action_1,
   action_2,
   action_3,
   action_4,
   action_5,
   action_6,
   action_7,
   action_8,
   action_9,
   action_10,
   action_11,
   action_12,
   action_13,
   action_14,
   action_15,
   action_16,
   action_17,
   action_18,
   action_19,
   action_20,
   action_21,
   action_22,
   action_23,
   action_24,
   action_25,
   action_26,
   action_27,
   action_28,
   action_29,
   action_30,
   action_31 :: () => Int -> ({-HappyReduction (Err) = -}
  	   Int 
  	-> (Token)
  	-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Err) HappyAbsSyn)
  	-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Err) HappyAbsSyn)] 
  	-> HappyStk HappyAbsSyn 
  	-> [(Token)] -> (Err) HappyAbsSyn)
  
  happyReduce_1,
   happyReduce_2,
   happyReduce_3,
   happyReduce_4,
   happyReduce_5,
   happyReduce_6,
   happyReduce_7,
   happyReduce_8,
   happyReduce_9,
   happyReduce_10,
   happyReduce_11,
   happyReduce_12,
   happyReduce_13,
   happyReduce_14,
   happyReduce_15,
   happyReduce_16,
   happyReduce_17,
   happyReduce_18,
   happyReduce_19 :: () => ({-HappyReduction (Err) = -}
  	   Int 
  	-> (Token)
  	-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Err) HappyAbsSyn)
  	-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Err) HappyAbsSyn)] 
  	-> HappyStk HappyAbsSyn 
  	-> [(Token)] -> (Err) HappyAbsSyn)
  
  happyExpList :: Happy_Data_Array.Array Int Int
  happyExpList = Happy_Data_Array.listArray (0,51) ([0,128,32768,0,0,4608,0,2048,0,0,0,0,0,0,0,256,28672,0,8,0,0,0,0,0,0,0,64,512,0,2,4096,0,2048,0,0,64,0,16,4096,0,0,0,0,512,0,0,896,0,0,0,0
  	])
  
  {-# NOINLINE happyExpListPerState #-}
  happyExpListPerState st =
      token_strs_expected
    where token_strs = ["error","%dummy","%start_pTargetDPs","Integer","Id","Decision","ListDecision","DecisionPath","ListDecisionPath","DecisionPaths","ListId","DecPathBind","ListDecPathBind","TargetDPs","'('","')'","','","':'","'All'","'None'","'['","']'","L_integ","L_Id","%eof"]
          bit_start = st * 25
          bit_end = (st + 1) * 25
          read_bit = readArrayBit happyExpList
          bits = map read_bit [bit_start..bit_end - 1]
          bits_indexed = zip bits [0..24]
          token_strs_expected = concatMap f bits_indexed
          f (False, _) = []
          f (True, nr) = [token_strs !! nr]
  
  action_0 (24) = happyShift action_7
  action_0 (5) = happyGoto action_3
  action_0 (12) = happyGoto action_4
  action_0 (13) = happyGoto action_5
  action_0 (14) = happyGoto action_6
  action_0 _ = happyFail (happyExpListPerState 0)
  
  action_1 (23) = happyShift action_2
  action_1 _ = happyFail (happyExpListPerState 1)
  
  action_2 _ = happyReduce_1
  
  action_3 (15) = happyShift action_9
  action_3 (18) = happyShift action_10
  action_3 _ = happyFail (happyExpListPerState 3)
  
  action_4 (24) = happyShift action_7
  action_4 (5) = happyGoto action_3
  action_4 (12) = happyGoto action_4
  action_4 (13) = happyGoto action_8
  action_4 _ = happyReduce_17
  
  action_5 _ = happyReduce_19
  
  action_6 (25) = happyAccept
  action_6 _ = happyFail (happyExpListPerState 6)
  
  action_7 _ = happyReduce_2
  
  action_8 _ = happyReduce_18
  
  action_9 (24) = happyShift action_7
  action_9 (5) = happyGoto action_17
  action_9 (11) = happyGoto action_18
  action_9 _ = happyFail (happyExpListPerState 9)
  
  action_10 (19) = happyShift action_14
  action_10 (20) = happyShift action_15
  action_10 (21) = happyShift action_16
  action_10 (8) = happyGoto action_11
  action_10 (9) = happyGoto action_12
  action_10 (10) = happyGoto action_13
  action_10 _ = happyReduce_7
  
  action_11 (17) = happyShift action_24
  action_11 _ = happyReduce_8
  
  action_12 _ = happyReduce_10
  
  action_13 _ = happyReduce_16
  
  action_14 _ = happyReduce_11
  
  action_15 _ = happyReduce_12
  
  action_16 (23) = happyShift action_2
  action_16 (4) = happyGoto action_21
  action_16 (6) = happyGoto action_22
  action_16 (7) = happyGoto action_23
  action_16 _ = happyFail (happyExpListPerState 16)
  
  action_17 (17) = happyShift action_20
  action_17 _ = happyReduce_13
  
  action_18 (16) = happyShift action_19
  action_18 _ = happyFail (happyExpListPerState 18)
  
  action_19 (18) = happyShift action_29
  action_19 _ = happyFail (happyExpListPerState 19)
  
  action_20 (24) = happyShift action_7
  action_20 (5) = happyGoto action_17
  action_20 (11) = happyGoto action_28
  action_20 _ = happyFail (happyExpListPerState 20)
  
  action_21 _ = happyReduce_3
  
  action_22 (17) = happyShift action_27
  action_22 _ = happyReduce_4
  
  action_23 (22) = happyShift action_26
  action_23 _ = happyFail (happyExpListPerState 23)
  
  action_24 (21) = happyShift action_16
  action_24 (8) = happyGoto action_11
  action_24 (9) = happyGoto action_25
  action_24 _ = happyReduce_7
  
  action_25 _ = happyReduce_9
  
  action_26 _ = happyReduce_6
  
  action_27 (23) = happyShift action_2
  action_27 (4) = happyGoto action_21
  action_27 (6) = happyGoto action_22
  action_27 (7) = happyGoto action_31
  action_27 _ = happyFail (happyExpListPerState 27)
  
  action_28 _ = happyReduce_14
  
  action_29 (19) = happyShift action_14
  action_29 (20) = happyShift action_15
  action_29 (21) = happyShift action_16
  action_29 (8) = happyGoto action_11
  action_29 (9) = happyGoto action_12
  action_29 (10) = happyGoto action_30
  action_29 _ = happyReduce_7
  
  action_30 _ = happyReduce_15
  
  action_31 _ = happyReduce_5
  
  happyReduce_1 = happySpecReduce_1  4 happyReduction_1
  happyReduction_1 (HappyTerminal (PT _ (TI happy_var_1)))
  	 =  HappyAbsSyn4
  		 ((read ( happy_var_1)) :: Integer
  	)
  happyReduction_1 _  = notHappyAtAll 
  
  happyReduce_2 = happySpecReduce_1  5 happyReduction_2
  happyReduction_2 (HappyTerminal (PT _ (T_Id happy_var_1)))
  	 =  HappyAbsSyn5
  		 (Id (happy_var_1)
  	)
  happyReduction_2 _  = notHappyAtAll 
  
  happyReduce_3 = happySpecReduce_1  6 happyReduction_3
  happyReduction_3 (HappyAbsSyn4  happy_var_1)
  	 =  HappyAbsSyn4
  		 (happy_var_1
  	)
  happyReduction_3 _  = notHappyAtAll 
  
  happyReduce_4 = happySpecReduce_1  7 happyReduction_4
  happyReduction_4 (HappyAbsSyn4  happy_var_1)
  	 =  HappyAbsSyn7
  		 ((:[]) happy_var_1
  	)
  happyReduction_4 _  = notHappyAtAll 
  
  happyReduce_5 = happySpecReduce_3  7 happyReduction_5
  happyReduction_5 (HappyAbsSyn7  happy_var_3)
  	_
  	(HappyAbsSyn4  happy_var_1)
  	 =  HappyAbsSyn7
  		 (happy_var_3 ++ (happy_var_1:[])
  	)
  happyReduction_5 _ _ _  = notHappyAtAll 
  
  happyReduce_6 = happySpecReduce_3  8 happyReduction_6
  happyReduction_6 _
  	(HappyAbsSyn7  happy_var_2)
  	_
  	 =  HappyAbsSyn8
  		 (LDP happy_var_2
  	)
  happyReduction_6 _ _ _  = notHappyAtAll 
  
  happyReduce_7 = happySpecReduce_0  9 happyReduction_7
  happyReduction_7  =  HappyAbsSyn9
  		 ([]
  	)
  
  happyReduce_8 = happySpecReduce_1  9 happyReduction_8
  happyReduction_8 (HappyAbsSyn8  happy_var_1)
  	 =  HappyAbsSyn9
  		 ((:[]) happy_var_1
  	)
  happyReduction_8 _  = notHappyAtAll 
  
  happyReduce_9 = happySpecReduce_3  9 happyReduction_9
  happyReduction_9 (HappyAbsSyn9  happy_var_3)
  	_
  	(HappyAbsSyn8  happy_var_1)
  	 =  HappyAbsSyn9
  		 ((:) happy_var_1 happy_var_3
  	)
  happyReduction_9 _ _ _  = notHappyAtAll 
  
  happyReduce_10 = happySpecReduce_1  10 happyReduction_10
  happyReduction_10 (HappyAbsSyn9  happy_var_1)
  	 =  HappyAbsSyn9
  		 (happy_var_1
  	)
  happyReduction_10 _  = notHappyAtAll 
  
  happyReduce_11 = happySpecReduce_1  10 happyReduction_11
  happyReduction_11 _
  	 =  HappyAbsSyn9
  		 ([LDP []]
  	)
  
  happyReduce_12 = happySpecReduce_1  10 happyReduction_12
  happyReduction_12 _
  	 =  HappyAbsSyn9
  		 ([]
  	)
  
  happyReduce_13 = happySpecReduce_1  11 happyReduction_13
  happyReduction_13 (HappyAbsSyn5  happy_var_1)
  	 =  HappyAbsSyn11
  		 ((:[]) happy_var_1
  	)
  happyReduction_13 _  = notHappyAtAll 
  
  happyReduce_14 = happySpecReduce_3  11 happyReduction_14
  happyReduction_14 (HappyAbsSyn11  happy_var_3)
  	_
  	(HappyAbsSyn5  happy_var_1)
  	 =  HappyAbsSyn11
  		 ((:) happy_var_1 happy_var_3
  	)
  happyReduction_14 _ _ _  = notHappyAtAll 
  
  happyReduce_15 = happyReduce 6 12 happyReduction_15
  happyReduction_15 ((HappyAbsSyn9  happy_var_6) `HappyStk`
  	_ `HappyStk`
  	_ `HappyStk`
  	_ `HappyStk`
  	_ `HappyStk`
  	(HappyAbsSyn5  happy_var_1) `HappyStk`
  	happyRest)
  	 = HappyAbsSyn12
  		 (buildDecisionPaths happy_var_1 happy_var_6
  	) `HappyStk` happyRest
  
  happyReduce_16 = happySpecReduce_3  12 happyReduction_16
  happyReduction_16 (HappyAbsSyn9  happy_var_3)
  	_
  	(HappyAbsSyn5  happy_var_1)
  	 =  HappyAbsSyn12
  		 (buildDecisionPaths happy_var_1 happy_var_3
  	)
  happyReduction_16 _ _ _  = notHappyAtAll 
  
  happyReduce_17 = happySpecReduce_1  13 happyReduction_17
  happyReduction_17 (HappyAbsSyn12  happy_var_1)
  	 =  HappyAbsSyn13
  		 ((:[]) happy_var_1
  	)
  happyReduction_17 _  = notHappyAtAll 
  
  happyReduce_18 = happySpecReduce_2  13 happyReduction_18
  happyReduction_18 (HappyAbsSyn13  happy_var_2)
  	(HappyAbsSyn12  happy_var_1)
  	 =  HappyAbsSyn13
  		 ((:) happy_var_1 happy_var_2
  	)
  happyReduction_18 _ _  = notHappyAtAll 
  
  happyReduce_19 = happySpecReduce_1  14 happyReduction_19
  happyReduction_19 (HappyAbsSyn13  happy_var_1)
  	 =  HappyAbsSyn14
  		 (happy_var_1
  	)
  happyReduction_19 _  = notHappyAtAll 
  
  happyNewToken action sts stk [] =
  	action 25 25 notHappyAtAll (HappyState action) sts stk []
  
  happyNewToken action sts stk (tk:tks) =
  	let cont i = action i i tk (HappyState action) sts stk tks in
  	case tk of {
  	PT _ (TS _ 1) -> cont 15;
  	PT _ (TS _ 2) -> cont 16;
  	PT _ (TS _ 3) -> cont 17;
  	PT _ (TS _ 4) -> cont 18;
  	PT _ (TS _ 5) -> cont 19;
  	PT _ (TS _ 6) -> cont 20;
  	PT _ (TS _ 7) -> cont 21;
  	PT _ (TS _ 8) -> cont 22;
  	PT _ (TI happy_dollar_dollar) -> cont 23;
  	PT _ (T_Id happy_dollar_dollar) -> cont 24;
  	_ -> happyError' ((tk:tks), [])
  	}
  
  happyError_ explist 25 tk tks = happyError' (tks, explist)
  happyError_ explist _ tk tks = happyError' ((tk:tks), explist)
  
  happyThen :: () => Err a -> (a -> Err b) -> Err b
  happyThen = (thenM)
  happyReturn :: () => a -> Err a
  happyReturn = (returnM)
  happyThen1 m k tks = (thenM) m (\a -> k a tks)
  happyReturn1 :: () => a -> b -> Err a
  happyReturn1 = \a tks -> (returnM) a
  happyError' :: () => ([(Token)], [String]) -> Err a
  happyError' = (\(tokens, _) -> happyError tokens)
  pTargetDPs tks = happySomeParser where
   happySomeParser = happyThen (happyParse action_0 tks) (\x -> case x of {HappyAbsSyn14 z -> happyReturn z; _other -> notHappyAtAll })
  
  happySeq = happyDontSeq
  
  
  buildDecisionPaths  :: Id -> [LDecisionPath] -> (String, [LDecisionPath])
  buildDecisionPaths (Id fun) dps = (fun, dps)
  
  rawparserTargetDPs :: String -> Err TargetDPs
  rawparserTargetDPs = pTargetDPs . tokens
  
  returnM :: a -> Err a
  returnM = return
  
  thenM :: Err a -> (a -> Err b) -> Err b
  thenM = (>>=)
  
  happyError :: [Token] -> Err a
  happyError ts =
    Bad $ "syntax error at " ++ tokenPos ts ++
    case ts of
      []      -> []
      [Err _] -> " due to lexer error"
      t:_     -> " before `" ++ id(prToken t) ++ "'"
  
  myLexer = tokens
  {-# LINE 1 "templates/GenericTemplate.hs" #-}
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  -- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
  
  
  
  
  
  
  
  
  
  
  
  data Happy_IntList = HappyCons Int Happy_IntList
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  infixr 9 `HappyStk`
  data HappyStk a = HappyStk a (HappyStk a)
  
  -----------------------------------------------------------------------------
  -- starting the parse
  
  happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
  
  -----------------------------------------------------------------------------
  -- Accepting the parse
  
  -- If the current token is (1), 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 (1) tk st sts (_ `HappyStk` ans `HappyStk` _) =
          happyReturn1 ans
  happyAccept j tk st sts (HappyStk ans _) = 
           (happyReturn1 ans)
  
  -----------------------------------------------------------------------------
  -- Arrays only: do the next action
  
  
  
  
  indexShortOffAddr arr off = arr Happy_Data_Array.! off
  
  
  {-# INLINE happyLt #-}
  happyLt x y = (x < y)
  
  
  
  
  
  
  readArrayBit arr bit =
      Bits.testBit (indexShortOffAddr arr (bit `div` 16)) (bit `mod` 16)
  
  
  
  
  
  
  -----------------------------------------------------------------------------
  -- HappyState data type (not arrays)
  
  
  
  newtype HappyState b c = HappyState
          (Int ->                    -- token number
           Int ->                    -- token number (yes, again)
           b ->                           -- token semantic value
           HappyState b c ->              -- current state
           [HappyState b c] ->            -- state stack
           c)
  
  
  
  -----------------------------------------------------------------------------
  -- Shifting a token
  
  happyShift new_state (1) tk st sts stk@(x `HappyStk` _) =
       let i = (case x of { HappyErrorToken (i) -> i }) in
  --     trace "shifting the error token" $
       new_state i i tk (HappyState (new_state)) ((st):(sts)) (stk)
  
  happyShift new_state i tk st sts stk =
       happyNewToken new_state ((st):(sts)) ((HappyTerminal (tk))`HappyStk`stk)
  
  -- happyReduce is specialised for the common cases.
  
  happySpecReduce_0 i fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happySpecReduce_0 nt fn j tk st@((HappyState (action))) sts stk
       = action nt j tk st ((st):(sts)) (fn `HappyStk` stk)
  
  happySpecReduce_1 i fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happySpecReduce_1 nt fn j tk _ sts@(((st@(HappyState (action))):(_))) (v1`HappyStk`stk')
       = let r = fn v1 in
         happySeq r (action nt j tk st sts (r `HappyStk` stk'))
  
  happySpecReduce_2 i fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happySpecReduce_2 nt fn j tk _ ((_):(sts@(((st@(HappyState (action))):(_))))) (v1`HappyStk`v2`HappyStk`stk')
       = let r = fn v1 v2 in
         happySeq r (action nt j tk st sts (r `HappyStk` stk'))
  
  happySpecReduce_3 i fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happySpecReduce_3 nt fn j tk _ ((_):(((_):(sts@(((st@(HappyState (action))):(_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
       = let r = fn v1 v2 v3 in
         happySeq r (action nt j tk st sts (r `HappyStk` stk'))
  
  happyReduce k i fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happyReduce k nt fn j tk st sts stk
       = case happyDrop (k - ((1) :: Int)) sts of
           sts1@(((st1@(HappyState (action))):(_))) ->
                  let r = fn stk in  -- it doesn't hurt to always seq here...
                  happyDoSeq r (action nt j tk st1 sts1 r)
  
  happyMonadReduce k nt fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happyMonadReduce k nt fn j tk st sts stk =
        case happyDrop k ((st):(sts)) of
          sts1@(((st1@(HappyState (action))):(_))) ->
            let drop_stk = happyDropStk k stk in
            happyThen1 (fn stk tk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk))
  
  happyMonad2Reduce k nt fn (1) tk st sts stk
       = happyFail [] (1) tk st sts stk
  happyMonad2Reduce k nt fn j tk st sts stk =
        case happyDrop k ((st):(sts)) of
          sts1@(((st1@(HappyState (action))):(_))) ->
           let drop_stk = happyDropStk k stk
  
  
  
  
  
               _ = nt :: Int
               new_state = action
  
            in
            happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
  
  happyDrop (0) l = l
  happyDrop n ((_):(t)) = happyDrop (n - ((1) :: Int)) t
  
  happyDropStk (0) l = l
  happyDropStk n (x `HappyStk` xs) = happyDropStk (n - ((1)::Int)) xs
  
  -----------------------------------------------------------------------------
  -- Moving to a new state after a reduction
  
  
  
  
  
  
  
  
  
  happyGoto action j tk st = action j j tk (HappyState action)
  
  
  -----------------------------------------------------------------------------
  -- Error recovery ((1) is the error token)
  
  -- parse error if we are in recovery and we fail again
  happyFail explist (1) tk old_st _ stk@(x `HappyStk` _) =
       let i = (case x of { HappyErrorToken (i) -> i }) in
  --      trace "failing" $ 
          happyError_ explist i tk
  
  {-  We don't need state discarding for our restricted implementation of
      "error".  In fact, it can cause some bogus parses, so I've disabled it
      for now --SDM
  
  -- discard a state
  happyFail  (1) tk old_st (((HappyState (action))):(sts)) 
                                                  (saved_tok `HappyStk` _ `HappyStk` stk) =
  --      trace ("discarding state, depth " ++ show (length stk))  $
          action (1) (1) tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))
  -}
  
  -- Enter error recovery: generate an error token,
  --                       save the old token and carry on.
  happyFail explist i tk (HappyState (action)) sts stk =
  --      trace "entering error recovery" $
          action (1) (1) tk (HappyState (action)) sts ( (HappyErrorToken (i)) `HappyStk` stk)
  
  -- Internal happy errors:
  
  notHappyAtAll :: a
  notHappyAtAll = error "Internal Happy error\n"
  
  -----------------------------------------------------------------------------
  -- Hack to get the typechecker to accept our action functions
  
  
  
  
  
  
  
  -----------------------------------------------------------------------------
  -- Seq-ing.  If the --strict flag is given, then Happy emits 
  --      happySeq = happyDoSeq
  -- otherwise it emits
  --      happySeq = happyDontSeq
  
  happyDoSeq, happyDontSeq :: a -> b -> b
  happyDoSeq   a b = a `seq` b
  happyDontSeq a b = b
  
  -----------------------------------------------------------------------------
  -- Don't inline any functions from the template.  GHC has a nasty habit
  -- of deciding to inline happyGoto everywhere, which increases the size of
  -- the generated parser quite a bit.
  
  
  
  
  
  
  
  
  
  {-# NOINLINE 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.
  
  