    {-# OPTIONS_GHC -w #-}
    {-# OPTIONS -fglasgow-exts -cpp #-}
    {-# LANGUAGE BangPatterns #-} -- required for versions of Happy before 1.18.6
    -- The above warning supression flag is a temporary kludge.
    -- While working on this module you are encouraged to remove it and fix
    -- any warnings in the module. See
    --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
    -- for details

    module Text.Pandoc.Readers.Haddock.Parse (parseString, parseParas) where

    import Text.Pandoc.Readers.Haddock.Lex
    import Text.Pandoc.Builder
    import Text.Pandoc.Shared (trim, trimr)
    import Data.Generics (everywhere, mkT)
    import Data.Char  (isSpace)
    import Data.Maybe (fromMaybe)
    import Data.List  (stripPrefix, intersperse)
    import Data.Monoid (mempty, mconcat)
    import qualified Data.Array as Happy_Data_Array
    import qualified GHC.Exts as Happy_GHC_Exts

    -- parser produced by Happy Version 1.19.0

    newtype HappyAbsSyn  = HappyAbsSyn HappyAny
    #if __GLASGOW_HASKELL__ >= 607
    type HappyAny = Happy_GHC_Exts.Any
    #else
    type HappyAny = forall a . a
    #endif
    happyIn5 :: (Blocks) -> (HappyAbsSyn )
    happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn5 #-}
    happyOut5 :: (HappyAbsSyn ) -> (Blocks)
    happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut5 #-}
    happyIn6 :: (Blocks) -> (HappyAbsSyn )
    happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn6 #-}
    happyOut6 :: (HappyAbsSyn ) -> (Blocks)
    happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut6 #-}
    happyIn7 :: (Blocks) -> (HappyAbsSyn )
    happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn7 #-}
    happyOut7 :: (HappyAbsSyn ) -> (Blocks)
    happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut7 #-}
    happyIn8 :: (Blocks) -> (HappyAbsSyn )
    happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn8 #-}
    happyOut8 :: (HappyAbsSyn ) -> (Blocks)
    happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut8 #-}
    happyIn9 :: ((Inlines, [Blocks])) -> (HappyAbsSyn )
    happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn9 #-}
    happyOut9 :: (HappyAbsSyn ) -> ((Inlines, [Blocks]))
    happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut9 #-}
    happyIn10 :: (Blocks) -> (HappyAbsSyn )
    happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn10 #-}
    happyOut10 :: (HappyAbsSyn ) -> (Blocks)
    happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut10 #-}
    happyIn11 :: (String) -> (HappyAbsSyn )
    happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn11 #-}
    happyOut11 :: (HappyAbsSyn ) -> (String)
    happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut11 #-}
    happyIn12 :: (Blocks) -> (HappyAbsSyn )
    happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn12 #-}
    happyOut12 :: (HappyAbsSyn ) -> (Blocks)
    happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut12 #-}
    happyIn13 :: (Blocks) -> (HappyAbsSyn )
    happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn13 #-}
    happyOut13 :: (HappyAbsSyn ) -> (Blocks)
    happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut13 #-}
    happyIn14 :: (Blocks) -> (HappyAbsSyn )
    happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn14 #-}
    happyOut14 :: (HappyAbsSyn ) -> (Blocks)
    happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut14 #-}
    happyIn15 :: (String) -> (HappyAbsSyn )
    happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn15 #-}
    happyOut15 :: (HappyAbsSyn ) -> (String)
    happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut15 #-}
    happyIn16 :: (Inlines) -> (HappyAbsSyn )
    happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn16 #-}
    happyOut16 :: (HappyAbsSyn ) -> (Inlines)
    happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut16 #-}
    happyIn17 :: (Inlines) -> (HappyAbsSyn )
    happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn17 #-}
    happyOut17 :: (HappyAbsSyn ) -> (Inlines)
    happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut17 #-}
    happyIn18 :: (Inlines) -> (HappyAbsSyn )
    happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn18 #-}
    happyOut18 :: (HappyAbsSyn ) -> (Inlines)
    happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut18 #-}
    happyIn19 :: (Inlines) -> (HappyAbsSyn )
    happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn19 #-}
    happyOut19 :: (HappyAbsSyn ) -> (Inlines)
    happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut19 #-}
    happyIn20 :: (String) -> (HappyAbsSyn )
    happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyIn20 #-}
    happyOut20 :: (HappyAbsSyn ) -> (String)
    happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOut20 #-}
    happyInTok :: (LToken) -> (HappyAbsSyn )
    happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyInTok #-}
    happyOutTok :: (HappyAbsSyn ) -> (LToken)
    happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
    {-# INLINE happyOutTok #-}

    happyActOffsets :: HappyAddr
    happyActOffsets = HappyA# "\xff\xff\x31\x00\x11\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x00\x00\x31\x00\x00\x00\x6d\x00\x31\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x21\x00\x6f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x68\x00\x68\x00\x67\x00\xff\xff\x00\x00\xff\xff\x5e\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x4b\x00\x4e\x00\x3d\x00\x6d\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyGotoOffsets :: HappyAddr
    happyGotoOffsets = HappyA# "\x63\x00\x98\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x6c\x00\x00\x00\x1e\x00\x35\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x8a\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x45\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x13\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\xf9\xff\x00\x00\x00\x00\x00\x00\x00\x00"#

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

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

    happyTable :: HappyAddr
    happyTable = HappyA# "\x00\x00\x10\x00\x11\x00\x38\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x2f\x00\x2b\x00\x1c\x00\x21\x00\x1d\x00\x10\x00\x11\x00\x33\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x30\x00\x2b\x00\x1c\x00\x10\x00\x1d\x00\x35\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x2a\x00\x2b\x00\x19\x00\x1a\x00\x1b\x00\x2e\x00\x0b\x00\x1c\x00\x10\x00\x1d\x00\x24\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x39\x00\x0d\x00\x27\x00\x0e\x00\x32\x00\x29\x00\x0d\x00\x1c\x00\x0e\x00\x1d\x00\x37\x00\x1f\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x37\x00\x0c\x00\x0d\x00\x33\x00\x0e\x00\x21\x00\x1f\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x29\x00\x0c\x00\x0d\x00\x35\x00\x0e\x00\x1e\x00\x1f\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x37\x00\x0c\x00\x0d\x00\x24\x00\x0e\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x2d\x00\x0d\x00\x23\x00\x0e\x00\x19\x00\xff\xff\x29\x00\x1c\x00\x2d\x00\x1d\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x1b\x00\x0c\x00\x0d\x00\x23\x00\x0e\x00\x25\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x00\x00\x0c\x00\x0d\x00\x00\x00\x0e\x00\x26\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x00\x00\x0c\x00\x0d\x00\x00\x00\x0e\x00\x1d\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

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

    happy_n_terms = 21 :: Int
    happy_n_nonterms = 16 :: Int

    happyReduce_2 = happySpecReduce_3  0# happyReduction_2
    happyReduction_2 happy_x_3
    	happy_x_2
    	happy_x_1
    	 =  case happyOut6 happy_x_1 of { happy_var_1 ->
    	case happyOut5 happy_x_3 of { happy_var_3 ->
    	happyIn5
    		 (happy_var_1 <> happy_var_3
    	)}}

    happyReduce_3 = happySpecReduce_2  0# happyReduction_3
    happyReduction_3 happy_x_2
    	happy_x_1
    	 =  case happyOut5 happy_x_2 of { happy_var_2 ->
    	happyIn5
    		 (happy_var_2
    	)}

    happyReduce_4 = happySpecReduce_1  0# happyReduction_4
    happyReduction_4 happy_x_1
    	 =  case happyOut6 happy_x_1 of { happy_var_1 ->
    	happyIn5
    		 (happy_var_1
    	)}

    happyReduce_5 = happySpecReduce_0  0# happyReduction_5
    happyReduction_5  =  happyIn5
    		 (mempty
    	)

    happyReduce_6 = happySpecReduce_1  1# happyReduction_6
    happyReduction_6 happy_x_1
    	 =  case happyOut7 happy_x_1 of { happy_var_1 ->
    	happyIn6
    		 (bulletList [happy_var_1]
    	)}

    happyReduce_7 = happySpecReduce_1  1# happyReduction_7
    happyReduction_7 happy_x_1
    	 =  case happyOut8 happy_x_1 of { happy_var_1 ->
    	happyIn6
    		 (orderedList [happy_var_1]
    	)}

    happyReduce_8 = happySpecReduce_1  1# happyReduction_8
    happyReduction_8 happy_x_1
    	 =  case happyOut9 happy_x_1 of { happy_var_1 ->
    	happyIn6
    		 (definitionList [happy_var_1]
    	)}

    happyReduce_9 = happySpecReduce_1  1# happyReduction_9
    happyReduction_9 happy_x_1
    	 =  case happyOut10 happy_x_1 of { happy_var_1 ->
    	happyIn6
    		 (happy_var_1
    	)}

    happyReduce_10 = happySpecReduce_2  2# happyReduction_10
    happyReduction_10 happy_x_2
    	happy_x_1
    	 =  case happyOut10 happy_x_2 of { happy_var_2 ->
    	happyIn7
    		 (happy_var_2
    	)}

    happyReduce_11 = happySpecReduce_2  3# happyReduction_11
    happyReduction_11 happy_x_2
    	happy_x_1
    	 =  case happyOut10 happy_x_2 of { happy_var_2 ->
    	happyIn8
    		 (happy_var_2
    	)}

    happyReduce_12 = happyReduce 4# 4# happyReduction_12
    happyReduction_12 (happy_x_4 `HappyStk`
    	happy_x_3 `HappyStk`
    	happy_x_2 `HappyStk`
    	happy_x_1 `HappyStk`
    	happyRest)
    	 = case happyOut16 happy_x_2 of { happy_var_2 ->
    	case happyOut16 happy_x_4 of { happy_var_4 ->
    	happyIn9
    		 ((trimInlines happy_var_2, [plain $ trimInlines happy_var_4])
    	) `HappyStk` happyRest}}

    happyReduce_13 = happySpecReduce_1  5# happyReduction_13
    happyReduction_13 happy_x_1
    	 =  case happyOut16 happy_x_1 of { happy_var_1 ->
    	happyIn10
    		 (para' happy_var_1
    	)}

    happyReduce_14 = happySpecReduce_1  5# happyReduction_14
    happyReduction_14 happy_x_1
    	 =  case happyOut11 happy_x_1 of { happy_var_1 ->
    	happyIn10
    		 (codeBlockWith ([], ["haskell"], []) happy_var_1
    	)}

    happyReduce_15 = happySpecReduce_1  5# happyReduction_15
    happyReduction_15 happy_x_1
    	 =  case happyOut12 happy_x_1 of { happy_var_1 ->
    	happyIn10
    		 (happy_var_1
    	)}

    happyReduce_16 = happySpecReduce_1  5# happyReduction_16
    happyReduction_16 happy_x_1
    	 =  case happyOut13 happy_x_1 of { happy_var_1 ->
    	happyIn10
    		 (happy_var_1
    	)}

    happyReduce_17 = happySpecReduce_2  6# happyReduction_17
    happyReduction_17 happy_x_2
    	happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokBirdTrack happy_var_1,_)) ->
    	case happyOut11 happy_x_2 of { happy_var_2 ->
    	happyIn11
    		 (happy_var_1 ++ happy_var_2
    	)}}

    happyReduce_18 = happySpecReduce_1  6# happyReduction_18
    happyReduction_18 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokBirdTrack happy_var_1,_)) ->
    	happyIn11
    		 (happy_var_1
    	)}

    happyReduce_19 = happySpecReduce_1  7# happyReduction_19
    happyReduction_19 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokProperty happy_var_1,_)) ->
    	happyIn12
    		 (makeProperty happy_var_1
    	)}

    happyReduce_20 = happySpecReduce_2  8# happyReduction_20
    happyReduction_20 happy_x_2
    	happy_x_1
    	 =  case happyOut14 happy_x_1 of { happy_var_1 ->
    	case happyOut13 happy_x_2 of { happy_var_2 ->
    	happyIn13
    		 (happy_var_1 <> happy_var_2
    	)}}

    happyReduce_21 = happySpecReduce_1  8# happyReduction_21
    happyReduction_21 happy_x_1
    	 =  case happyOut14 happy_x_1 of { happy_var_1 ->
    	happyIn13
    		 (happy_var_1
    	)}

    happyReduce_22 = happySpecReduce_3  9# happyReduction_22
    happyReduction_22 happy_x_3
    	happy_x_2
    	happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokExamplePrompt happy_var_1,_)) ->
    	case happyOutTok happy_x_2 of { ((TokExampleExpression happy_var_2,_)) ->
    	case happyOut15 happy_x_3 of { happy_var_3 ->
    	happyIn14
    		 (makeExample happy_var_1 happy_var_2 (lines happy_var_3)
    	)}}}

    happyReduce_23 = happySpecReduce_2  9# happyReduction_23
    happyReduction_23 happy_x_2
    	happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokExamplePrompt happy_var_1,_)) ->
    	case happyOutTok happy_x_2 of { ((TokExampleExpression happy_var_2,_)) ->
    	happyIn14
    		 (makeExample happy_var_1 happy_var_2 []
    	)}}

    happyReduce_24 = happySpecReduce_2  10# happyReduction_24
    happyReduction_24 happy_x_2
    	happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokExampleResult happy_var_1,_)) ->
    	case happyOut15 happy_x_2 of { happy_var_2 ->
    	happyIn15
    		 (happy_var_1 ++ happy_var_2
    	)}}

    happyReduce_25 = happySpecReduce_1  10# happyReduction_25
    happyReduction_25 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokExampleResult happy_var_1,_)) ->
    	happyIn15
    		 (happy_var_1
    	)}

    happyReduce_26 = happySpecReduce_2  11# happyReduction_26
    happyReduction_26 happy_x_2
    	happy_x_1
    	 =  case happyOut17 happy_x_1 of { happy_var_1 ->
    	case happyOut16 happy_x_2 of { happy_var_2 ->
    	happyIn16
    		 (happy_var_1 <> happy_var_2
    	)}}

    happyReduce_27 = happySpecReduce_1  11# happyReduction_27
    happyReduction_27 happy_x_1
    	 =  case happyOut17 happy_x_1 of { happy_var_1 ->
    	happyIn16
    		 (happy_var_1
    	)}

    happyReduce_28 = happySpecReduce_1  12# happyReduction_28
    happyReduction_28 happy_x_1
    	 =  case happyOut19 happy_x_1 of { happy_var_1 ->
    	happyIn17
    		 (happy_var_1
    	)}

    happyReduce_29 = happySpecReduce_3  12# happyReduction_29
    happyReduction_29 happy_x_3
    	happy_x_2
    	happy_x_1
    	 =  case happyOut18 happy_x_2 of { happy_var_2 ->
    	happyIn17
    		 (monospace happy_var_2
    	)}

    happyReduce_30 = happySpecReduce_2  13# happyReduction_30
    happyReduction_30 happy_x_2
    	happy_x_1
    	 =  case happyOut18 happy_x_2 of { happy_var_2 ->
    	happyIn18
    		 (linebreak <> happy_var_2
    	)}

    happyReduce_31 = happySpecReduce_2  13# happyReduction_31
    happyReduction_31 happy_x_2
    	happy_x_1
    	 =  case happyOut19 happy_x_1 of { happy_var_1 ->
    	case happyOut18 happy_x_2 of { happy_var_2 ->
    	happyIn18
    		 (happy_var_1 <> happy_var_2
    	)}}

    happyReduce_32 = happySpecReduce_1  13# happyReduction_32
    happyReduction_32 happy_x_1
    	 =  case happyOut19 happy_x_1 of { happy_var_1 ->
    	happyIn18
    		 (happy_var_1
    	)}

    happyReduce_33 = happySpecReduce_1  14# happyReduction_33
    happyReduction_33 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokString happy_var_1,_)) ->
    	happyIn19
    		 (text happy_var_1
    	)}

    happyReduce_34 = happySpecReduce_1  14# happyReduction_34
    happyReduction_34 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokEmphasis happy_var_1,_)) ->
    	happyIn19
    		 (emph (str happy_var_1)
    	)}

    happyReduce_35 = happySpecReduce_1  14# happyReduction_35
    happyReduction_35 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokURL happy_var_1,_)) ->
    	happyIn19
    		 (makeHyperlink happy_var_1
    	)}

    happyReduce_36 = happySpecReduce_1  14# happyReduction_36
    happyReduction_36 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokPic happy_var_1,_)) ->
    	happyIn19
    		 (image happy_var_1 happy_var_1 mempty
    	)}

    happyReduce_37 = happySpecReduce_1  14# happyReduction_37
    happyReduction_37 happy_x_1
    	 =  happyIn19
    		 (mempty
    	)

    happyReduce_38 = happySpecReduce_1  14# happyReduction_38
    happyReduction_38 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokIdent happy_var_1,_)) ->
    	happyIn19
    		 (codeWith ([], ["haskell"], []) happy_var_1
    	)}

    happyReduce_39 = happySpecReduce_3  14# happyReduction_39
    happyReduction_39 happy_x_3
    	happy_x_2
    	happy_x_1
    	 =  case happyOut20 happy_x_2 of { happy_var_2 ->
    	happyIn19
    		 (codeWith ([], ["haskell"], []) happy_var_2
    	)}

    happyReduce_40 = happySpecReduce_1  15# happyReduction_40
    happyReduction_40 happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokString happy_var_1,_)) ->
    	happyIn20
    		 (happy_var_1
    	)}

    happyReduce_41 = happySpecReduce_2  15# happyReduction_41
    happyReduction_41 happy_x_2
    	happy_x_1
    	 =  case happyOutTok happy_x_1 of { ((TokString happy_var_1,_)) ->
    	case happyOut20 happy_x_2 of { happy_var_2 ->
    	happyIn20
    		 (happy_var_1 ++ happy_var_2
    	)}}

    happyNewToken action sts stk [] =
    	happyDoAction 20# notHappyAtAll action sts stk []

    happyNewToken action sts stk (tk:tks) =
    	let cont i = happyDoAction i tk action sts stk tks in
    	case tk of {
    	(TokSpecial '/',_) -> cont 1#;
    	(TokSpecial '@',_) -> cont 2#;
    	(TokDefStart,_) -> cont 3#;
    	(TokDefEnd,_) -> cont 4#;
    	(TokSpecial '\"',_) -> cont 5#;
    	(TokURL happy_dollar_dollar,_) -> cont 6#;
    	(TokPic happy_dollar_dollar,_) -> cont 7#;
    	(TokAName happy_dollar_dollar,_) -> cont 8#;
    	(TokEmphasis happy_dollar_dollar,_) -> cont 9#;
    	(TokBullet,_) -> cont 10#;
    	(TokNumber,_) -> cont 11#;
    	(TokBirdTrack happy_dollar_dollar,_) -> cont 12#;
    	(TokProperty happy_dollar_dollar,_) -> cont 13#;
    	(TokExamplePrompt happy_dollar_dollar,_) -> cont 14#;
    	(TokExampleResult happy_dollar_dollar,_) -> cont 15#;
    	(TokExampleExpression happy_dollar_dollar,_) -> cont 16#;
    	(TokIdent happy_dollar_dollar,_) -> cont 17#;
    	(TokPara,_) -> cont 18#;
    	(TokString happy_dollar_dollar,_) -> cont 19#;
    	_ -> happyError' (tk:tks)
    	}

    happyError_ 20# tk tks = happyError' tks
    happyError_ _ tk tks = happyError' (tk:tks)

    happyThen :: () => Either [LToken] a -> (a -> Either [LToken] b) -> Either [LToken] b
    happyThen = (>>=)
    happyReturn :: () => a -> Either [LToken] a
    happyReturn = (return)
    happyThen1 m k tks = (>>=) m (\a -> k a tks)
    happyReturn1 :: () => a -> b -> Either [LToken] a
    happyReturn1 = \a tks -> (return) a
    happyError' :: () => [(LToken)] -> Either [LToken] a
    happyError' = happyError

    parseParas tks = happySomeParser where
      happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut5 x))

    parseString tks = happySomeParser where
      happySomeParser = happyThen (happyParse 1# tks) (\x -> happyReturn (happyOut16 x))

    happySeq = happyDontSeq

    happyError :: [LToken] -> Either [LToken] a
    happyError toks = Left toks

    para' :: Inlines -> Blocks
    para' = para . trimInlines

    monospace :: Inlines -> Inlines
    monospace = everywhere (mkT go)
      where
        go (Str s) = Code nullAttr s
        go x = x

    -- | Create a `Hyperlink` from given string.
    --
    -- A hyperlink consists of a URL and an optional label.  The label is separated
    -- from the url by one or more whitespace characters.
    makeHyperlink :: String -> Inlines
    makeHyperlink input = case break isSpace $ trim input of
      (url, "") -> link url url (str url)
      (url, lb) -> link url url (trimInlines $ text lb)

    makeProperty :: String -> Blocks
    makeProperty s = case trim s of
      'p':'r':'o':'p':'>':xs ->
        codeBlockWith ([], ["property"], []) (dropWhile isSpace xs)
      xs ->
        error $ "makeProperty: invalid input " ++ show xs

    -- | Create an 'Example', stripping superfluous characters as appropriate
    makeExample :: String -> String -> [String] -> Blocks
    makeExample prompt expression result =
        para $ codeWith ([], ["haskell","expr"], []) (trim expression)
            <> linebreak
            <> (mconcat $ intersperse linebreak $ map coder result')
      where
        -- 1. drop trailing whitespace from the prompt, remember the prefix
        prefix = takeWhile isSpace prompt

        -- 2. drop, if possible, the exact same sequence of whitespace
        -- characters from each result line
        --
        -- 3. interpret lines that only contain the string "<BLANKLINE>" as an
        -- empty line
        result' = map (substituteBlankLine . tryStripPrefix prefix) result
          where
            tryStripPrefix xs ys = fromMaybe ys $ stripPrefix xs ys

            substituteBlankLine "<BLANKLINE>" = ""
            substituteBlankLine line          = line
        coder = codeWith ([], ["result"], [])
    {-# LINE 1 "templates/GenericTemplate.hs" #-}
    {-# LINE 1 "templates/GenericTemplate.hs" #-}
    {-# LINE 1 "<command-line>" #-}
    {-# LINE 8 "<command-line>" #-}
    # 1 "/usr/include/stdc-predef.h" 1 3 4

    # 17 "/usr/include/stdc-predef.h" 3 4

    # 1 "/usr/include/i386-linux-gnu/bits/predefs.h" 1 3 4

    # 18 "/usr/include/i386-linux-gnu/bits/predefs.h" 3 4

    # 31 "/usr/include/stdc-predef.h" 2 3 4

    # 8 "<command-line>" 2
    {-# LINE 1 "templates/GenericTemplate.hs" #-}
    -- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp

    {-# LINE 13 "templates/GenericTemplate.hs" #-}

    #if __GLASGOW_HASKELL__ > 706
    #define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool)
    #define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)
    #define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool)
    #else
    #define LT(n,m) (n Happy_GHC_Exts.<# m)
    #define GTE(n,m) (n Happy_GHC_Exts.>=# m)
    #define EQ(n,m) (n Happy_GHC_Exts.==# m)
    #endif
    {-# LINE 45 "templates/GenericTemplate.hs" #-}

    data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList

    {-# LINE 66 "templates/GenericTemplate.hs" #-}

    {-# LINE 76 "templates/GenericTemplate.hs" #-}

    {-# LINE 85 "templates/GenericTemplate.hs" #-}

    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 0#, it means we've just accepted a partial
    -- parse (a %partial parser).  We must ignore the saved token on the top of
    -- the stack in this case.
    happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
    	happyReturn1 ans
    happyAccept j tk st sts (HappyStk ans _) =
    	(happyTcHack j (happyTcHack st)) (happyReturn1 ans)

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

    happyDoAction i tk st
    	= {- nothing -}

    	  case action of
    		0#		  -> {- nothing -}
    				     happyFail i tk st
    		-1# 	  -> {- nothing -}
    				     happyAccept i tk st
    		n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}

    				     (happyReduceArr Happy_Data_Array.! rule) i tk st
    				     where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
    		n		  -> {- nothing -}

    				     happyShift new_state i tk st
                                         where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
       where off    = indexShortOffAddr happyActOffsets st
             off_i  = (off Happy_GHC_Exts.+# i)
    	 check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
                      then EQ(indexShortOffAddr happyCheck off_i, i)
    		  else False
             action
              | check     = indexShortOffAddr happyTable off_i
              | otherwise = indexShortOffAddr happyDefActions st

    indexShortOffAddr (HappyA# arr) off =
    	Happy_GHC_Exts.narrow16Int# i
      where
            i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
            high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
            low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
            off' = off Happy_GHC_Exts.*# 2#

    data HappyAddr = HappyA# Happy_GHC_Exts.Addr#

    -----------------------------------------------------------------------------
    -- HappyState data type (not arrays)

    {-# LINE 169 "templates/GenericTemplate.hs" #-}

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

    happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
         let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
    --     trace "shifting the error token" $
         happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)

    happyShift new_state i tk st sts stk =
         happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)

    -- happyReduce is specialised for the common cases.

    happySpecReduce_0 i fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happySpecReduce_0 nt fn j tk st@((action)) sts stk
         = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)

    happySpecReduce_1 i fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
         = let r = fn v1 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happySpecReduce_2 i fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
         = let r = fn v1 v2 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happySpecReduce_3 i fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
         = let r = fn v1 v2 v3 in
           happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

    happyReduce k i fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happyReduce k nt fn j tk st sts stk
         = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
    	 sts1@((HappyCons (st1@(action)) (_))) ->
            	let r = fn stk in  -- it doesn't hurt to always seq here...
           		happyDoSeq r (happyGoto nt j tk st1 sts1 r)

    happyMonadReduce k nt fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happyMonadReduce k nt fn j tk st sts stk =
          case happyDrop k (HappyCons (st) (sts)) of
            sts1@((HappyCons (st1@(action)) (_))) ->
              let drop_stk = happyDropStk k stk in
              happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))

    happyMonad2Reduce k nt fn 0# tk st sts stk
         = happyFail 0# tk st sts stk
    happyMonad2Reduce k nt fn j tk st sts stk =
          case happyDrop k (HappyCons (st) (sts)) of
            sts1@((HappyCons (st1@(action)) (_))) ->
             let drop_stk = happyDropStk k stk

                 off = indexShortOffAddr happyGotoOffsets st1
                 off_i = (off Happy_GHC_Exts.+# nt)
                 new_state = indexShortOffAddr happyTable off_i

              in
              happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))

    happyDrop 0# l = l
    happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t

    happyDropStk 0# l = l
    happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs

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

    happyGoto nt j tk st =
       {- nothing -}
       happyDoAction j tk new_state
       where off = indexShortOffAddr happyGotoOffsets st
             off_i = (off Happy_GHC_Exts.+# nt)
             new_state = indexShortOffAddr happyTable off_i

    -----------------------------------------------------------------------------
    -- Error recovery (0# is the error token)

    -- parse error if we are in recovery and we fail again
    happyFail 0# tk old_st _ stk@(x `HappyStk` _) =
         let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
    --	trace "failing" $
            happyError_ 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  0# tk old_st (HappyCons ((action)) (sts))
    						(saved_tok `HappyStk` _ `HappyStk` stk) =
    --	trace ("discarding state, depth " ++ show (length stk))  $
    	happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))
    -}

    -- Enter error recovery: generate an error token,
    --                       save the old token and carry on.
    happyFail  i tk (action) sts stk =
    --      trace "entering error recovery" $
    	happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)

    -- Internal happy errors:

    notHappyAtAll :: a
    notHappyAtAll = error "Internal Happy error\n"

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

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

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

    happyDoSeq, happyDontSeq :: a -> b -> b
    happyDoSeq   a b = a `seq` b
    happyDontSeq a b = b

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

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

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

    -- end of Happy Template.