content: -- Language definition for CodeQL, generated by ast-generate. Do not edit!
  {-# LANGUAGE CPP #-}
  {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DeriveAnyClass #-}
  {-# LANGUAGE DeriveGeneric #-}
  {-# LANGUAGE DeriveTraversable #-}
  {-# LANGUAGE DerivingStrategies #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE FlexibleInstances #-}
  {-# LANGUAGE GeneralizedNewtypeDeriving #-}
  {-# LANGUAGE KindSignatures #-}
  {-# LANGUAGE MultiParamTypeClasses #-}
  {-# LANGUAGE QuantifiedConstraints #-}
  {-# LANGUAGE StandaloneDeriving #-}
  {-# LANGUAGE TemplateHaskell #-}
  {-# LANGUAGE TypeApplications #-}
  {-# LANGUAGE TypeOperators #-}
  {-# LANGUAGE UndecidableInstances #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports #-}
  
  module Language.CodeQL.AST (module Language.CodeQL.AST, getTestCorpusDir) where
  
  import qualified AST.Parse
  import qualified AST.Token
  import qualified AST.Traversable1.Class
  import qualified AST.Unmarshal
  import qualified Data.Foldable
  import qualified Data.List as Data.OldList
  import qualified Data.Maybe as GHC.Maybe
  import qualified Data.Text.Internal
  import qualified Data.Traversable
  import qualified GHC.Base
  import qualified GHC.Generics
  import qualified GHC.Records
  import qualified GHC.Show
  import qualified TreeSitter.Node
  import TreeSitter.QL (getTestCorpusDir)
  import qualified Prelude as GHC.Classes
  
  debugSymbolNames :: [GHC.Base.String]
  debugSymbolNames = debugSymbolNames_0
  
  debugSymbolNames_0 :: [GHC.Base.String]
  debugSymbolNames_0 =
    [ "end",
      "_lower_id",
      "_module",
      "_{",
      "_}",
      "_;",
      "_(",
      "_,",
      "_)",
      "_or",
      "_from",
      "_where",
      "_select",
      "_if",
      "_then",
      "_else",
      "_and",
      "_implies",
      "_|",
      "_.",
      "_[",
      "_]",
      "_..",
      "_order",
      "_by",
      "qldoc",
      "_::",
      "_float",
      "_int",
      "_string",
      "_upper_id",
      "_at_lower_id",
      "integer",
      "float",
      "string",
      "line_comment",
      "block_comment",
      "any",
      "as",
      "asc",
      "avg",
      "boolean",
      "class",
      "newtype",
      "count",
      "date",
      "desc",
      "exists",
      "extends",
      "false",
      "forall",
      "forex",
      "import",
      "in",
      "instanceof",
      "max",
      "min",
      "not",
      "none",
      "predicate",
      "rank",
      "result",
      "strictcount",
      "strictsum",
      "strictconcat",
      "concat",
      "sum",
      "super",
      "this",
      "true",
      "lt",
      "le",
      "eq",
      "gt",
      "ge",
      "underscore",
      "minus",
      "ne",
      "slash",
      "star",
      "mod",
      "plus",
      "ql",
      "module",
      "moduleMember",
      "imprt",
      "moduleAliasBody",
      "predicateAliasBody",
      "typeAliasBody",
      "classlessPredicate",
      "datatype",
      "datatypeBranches",
      "datatypeBranch",
      "select",
      "dataclass",
      "classMember",
      "charpred",
      "memberPredicate",
      "field",
      "_optbody",
      "empty",
      "body",
      "higherOrderTerm",
      "special_call",
      "prefix_cast",
      "unary_expr",
      "mul_expr",
      "add_expr",
      "in_expr",
      "comp_term",
      "instance_of",
      "negation",
      "if_term",
      "conjunction",
      "disjunction",
      "implication",
      "quantified",
      "specialId",
      "quantifier",
      "_call_arg",
      "qualifiedRhs",
      "classless_predicate_call",
      "qualified_expr",
      "super_ref",
      "full_aggregate_body",
      "expr_aggregate_body",
      "aggregate",
      "range",
      "par_expr",
      "_exprOrTerm",
      "_primary",
      "literal",
      "bool",
      "variable",
      "compop",
      "unop",
      "mulop",
      "addop",
      "closure",
      "direction",
      "varDecl",
      "asExprs",
      "asExpr",
      "orderBys",
      "orderBy",
      "literalId",
      "annotation",
      "annotName",
      "annotArg",
      "moduleName",
      "qualModuleExpr",
      "importModuleExpr",
      "moduleExpr",
      "typeLiteral",
      "simpleId",
      "className",
      "dbtype",
      "returnType",
      "typeExpr",
      "predicateName",
      "aritylessPredicateExpr",
      "predicateExpr",
      "varName",
      "aggId",
      "_ql_repeat1",
      "_moduleMember_repeat1",
      "_classlessPredicate_repeat1",
      "_datatypeBranches_repeat1",
      "_dataclass_repeat1",
      "_dataclass_repeat2",
      "_higherOrderTerm_repeat1",
      "_higherOrderTerm_repeat2",
      "_aggregate_repeat1",
      "_asExprs_repeat1",
      "_orderBys_repeat1",
      "_annotation_repeat1",
      "_qualModuleExpr_repeat1",
      "_importModuleExpr_repeat1"
    ]
  
  data AddExpr a = AddExpr
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      extraChildren :: (AST.Parse.Err (Addop a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1.
        AST.Traversable1.Class.Traversable1 a_1
      )
  
  instance AST.Unmarshal.SymbolMatching AddExpr where
    matchedSymbols _ = [107]
    showFailure _ node_2 =
      "expected "
        GHC.Base.<> ( "add_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_2 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_2) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_3 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_4 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_5 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_6 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_3
          c1_4 = TreeSitter.Node.nodeStartPoint node_2
        TreeSitter.Node.TSPoint
          r2_5
          c2_6 = TreeSitter.Node.nodeEndPoint node_2
  
  deriving instance GHC.Classes.Eq a_7 => GHC.Classes.Eq (AddExpr a_7)
  
  deriving instance GHC.Classes.Ord a_8 => GHC.Classes.Ord (AddExpr a_8)
  
  deriving instance GHC.Show.Show a_9 => GHC.Show.Show (AddExpr a_9)
  
  instance AST.Unmarshal.Unmarshal AddExpr
  
  instance Data.Foldable.Foldable AddExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AddExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AddExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Addop a = Addop
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Minus GHC.Generics.:+: Plus) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_10.
        AST.Traversable1.Class.Traversable1 a_10
      )
  
  instance AST.Unmarshal.SymbolMatching Addop where
    matchedSymbols _ = [137]
    showFailure _ node_11 =
      "expected "
        GHC.Base.<> ( "addop"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_11 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_11) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_12 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_13 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_14 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_15 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_12
          c1_13 = TreeSitter.Node.nodeStartPoint node_11
        TreeSitter.Node.TSPoint
          r2_14
          c2_15 = TreeSitter.Node.nodeEndPoint node_11
  
  deriving instance GHC.Classes.Eq a_16 => GHC.Classes.Eq (Addop a_16)
  
  deriving instance GHC.Classes.Ord a_17 => GHC.Classes.Ord (Addop a_17)
  
  deriving instance GHC.Show.Show a_18 => GHC.Show.Show (Addop a_18)
  
  instance AST.Unmarshal.Unmarshal Addop
  
  instance Data.Foldable.Foldable Addop where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Addop where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Addop where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AggId a = AggId
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Any GHC.Generics.:+: Avg GHC.Generics.:+: Concat GHC.Generics.:+: Count GHC.Generics.:+: Max GHC.Generics.:+: Min GHC.Generics.:+: Rank GHC.Generics.:+: Strictconcat GHC.Generics.:+: Strictcount GHC.Generics.:+: Strictsum GHC.Generics.:+: Sum) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_19.
        AST.Traversable1.Class.Traversable1 a_19
      )
  
  instance AST.Unmarshal.SymbolMatching AggId where
    matchedSymbols _ = [163]
    showFailure _ node_20 =
      "expected "
        GHC.Base.<> ( "aggId"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_20 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_20) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_21 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_22 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_23 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_24 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_21
          c1_22 = TreeSitter.Node.nodeStartPoint node_20
        TreeSitter.Node.TSPoint
          r2_23
          c2_24 = TreeSitter.Node.nodeEndPoint node_20
  
  deriving instance GHC.Classes.Eq a_25 => GHC.Classes.Eq (AggId a_25)
  
  deriving instance GHC.Classes.Ord a_26 => GHC.Classes.Ord (AggId a_26)
  
  deriving instance GHC.Show.Show a_27 => GHC.Show.Show (AggId a_27)
  
  instance AST.Unmarshal.Unmarshal AggId
  
  instance Data.Foldable.Foldable AggId where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AggId where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AggId where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Aggregate a = Aggregate
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: AggId GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: ExprAggregateBody GHC.Generics.:+: FullAggregateBody GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_28.
        AST.Traversable1.Class.Traversable1 a_28
      )
  
  instance AST.Unmarshal.SymbolMatching Aggregate where
    matchedSymbols _ = [126]
    showFailure _ node_29 =
      "expected "
        GHC.Base.<> ( "aggregate"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_29 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_29) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_30 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_31 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_32 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_33 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_30
          c1_31 = TreeSitter.Node.nodeStartPoint node_29
        TreeSitter.Node.TSPoint
          r2_32
          c2_33 = TreeSitter.Node.nodeEndPoint node_29
  
  deriving instance GHC.Classes.Eq a_34 => GHC.Classes.Eq (Aggregate a_34)
  
  deriving instance GHC.Classes.Ord a_35 => GHC.Classes.Ord (Aggregate a_35)
  
  deriving instance GHC.Show.Show a_36 => GHC.Show.Show (Aggregate a_36)
  
  instance AST.Unmarshal.Unmarshal Aggregate
  
  instance Data.Foldable.Foldable Aggregate where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Aggregate where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Aggregate where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotArg a = AnnotArg
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Result GHC.Generics.:+: SimpleId GHC.Generics.:+: This) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_37.
        AST.Traversable1.Class.Traversable1 a_37
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotArg where
    matchedSymbols _ = [148]
    showFailure _ node_38 =
      "expected "
        GHC.Base.<> ( "annotArg"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_38 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_38) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_39 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_40 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_41 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_42 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_39
          c1_40 = TreeSitter.Node.nodeStartPoint node_38
        TreeSitter.Node.TSPoint
          r2_41
          c2_42 = TreeSitter.Node.nodeEndPoint node_38
  
  deriving instance GHC.Classes.Eq a_43 => GHC.Classes.Eq (AnnotArg a_43)
  
  deriving instance GHC.Classes.Ord a_44 => GHC.Classes.Ord (AnnotArg a_44)
  
  deriving instance GHC.Show.Show a_45 => GHC.Show.Show (AnnotArg a_45)
  
  instance AST.Unmarshal.Unmarshal AnnotArg
  
  instance Data.Foldable.Foldable AnnotArg where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotArg where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotArg where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotName a = AnnotName {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_46.
        AST.Traversable1.Class.Traversable1 a_46
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotName where
    matchedSymbols _ = [147]
    showFailure _ node_47 =
      "expected "
        GHC.Base.<> ( "annotName"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_47 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_47) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_48 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_49 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_50 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_51 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_48
          c1_49 = TreeSitter.Node.nodeStartPoint node_47
        TreeSitter.Node.TSPoint
          r2_50
          c2_51 = TreeSitter.Node.nodeEndPoint node_47
  
  deriving instance GHC.Classes.Eq a_52 => GHC.Classes.Eq (AnnotName a_52)
  
  deriving instance GHC.Classes.Ord a_53 => GHC.Classes.Ord (AnnotName a_53)
  
  deriving instance GHC.Show.Show a_54 => GHC.Show.Show (AnnotName a_54)
  
  instance AST.Unmarshal.Unmarshal AnnotName
  
  instance Data.Foldable.Foldable AnnotName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Annotation a = Annotation
    { ann :: a,
      args :: ([AST.Parse.Err ((AnonymousComma GHC.Generics.:+: AnnotArg) a)]),
      name :: (AST.Parse.Err (AnnotName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_55.
        AST.Traversable1.Class.Traversable1 a_55
      )
  
  instance AST.Unmarshal.SymbolMatching Annotation where
    matchedSymbols _ = [146]
    showFailure _ node_56 =
      "expected "
        GHC.Base.<> ( "annotation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_56 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_56) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_57 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_58 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_59 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_60 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_57
          c1_58 = TreeSitter.Node.nodeStartPoint node_56
        TreeSitter.Node.TSPoint
          r2_59
          c2_60 = TreeSitter.Node.nodeEndPoint node_56
  
  deriving instance GHC.Classes.Eq a_61 => GHC.Classes.Eq (Annotation a_61)
  
  deriving instance GHC.Classes.Ord a_62 => GHC.Classes.Ord (Annotation a_62)
  
  deriving instance GHC.Show.Show a_63 => GHC.Show.Show (Annotation a_63)
  
  instance AST.Unmarshal.Unmarshal Annotation
  
  instance Data.Foldable.Foldable Annotation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Annotation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Annotation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AritylessPredicateExpr a = AritylessPredicateExpr
    { ann :: a,
      name :: (AST.Parse.Err (LiteralId a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ModuleExpr a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_64.
        AST.Traversable1.Class.Traversable1 a_64
      )
  
  instance AST.Unmarshal.SymbolMatching AritylessPredicateExpr where
    matchedSymbols _ = [160]
    showFailure _ node_65 =
      "expected "
        GHC.Base.<> ( "aritylessPredicateExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_65 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_65) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_66 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_67 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_68 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_69 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_66
          c1_67 = TreeSitter.Node.nodeStartPoint node_65
        TreeSitter.Node.TSPoint
          r2_68
          c2_69 = TreeSitter.Node.nodeEndPoint node_65
  
  deriving instance GHC.Classes.Eq a_70 => GHC.Classes.Eq (AritylessPredicateExpr a_70)
  
  deriving instance GHC.Classes.Ord a_71 => GHC.Classes.Ord (AritylessPredicateExpr a_71)
  
  deriving instance GHC.Show.Show a_72 => GHC.Show.Show (AritylessPredicateExpr a_72)
  
  instance AST.Unmarshal.Unmarshal AritylessPredicateExpr
  
  instance Data.Foldable.Foldable AritylessPredicateExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AritylessPredicateExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AritylessPredicateExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AsExpr a = AsExpr
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: As GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: VarName GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_73.
        AST.Traversable1.Class.Traversable1 a_73
      )
  
  instance AST.Unmarshal.SymbolMatching AsExpr where
    matchedSymbols _ = [142]
    showFailure _ node_74 =
      "expected "
        GHC.Base.<> ( "asExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_74 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_74) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_75 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_76 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_77 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_78 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_75
          c1_76 = TreeSitter.Node.nodeStartPoint node_74
        TreeSitter.Node.TSPoint
          r2_77
          c2_78 = TreeSitter.Node.nodeEndPoint node_74
  
  deriving instance GHC.Classes.Eq a_79 => GHC.Classes.Eq (AsExpr a_79)
  
  deriving instance GHC.Classes.Ord a_80 => GHC.Classes.Ord (AsExpr a_80)
  
  deriving instance GHC.Show.Show a_81 => GHC.Show.Show (AsExpr a_81)
  
  instance AST.Unmarshal.Unmarshal AsExpr
  
  instance Data.Foldable.Foldable AsExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AsExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AsExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AsExprs a = AsExprs
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (AsExpr a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_82.
        AST.Traversable1.Class.Traversable1 a_82
      )
  
  instance AST.Unmarshal.SymbolMatching AsExprs where
    matchedSymbols _ = [141]
    showFailure _ node_83 =
      "expected "
        GHC.Base.<> ( "asExprs"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_83 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_83) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_84 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_85 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_86 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_87 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_84
          c1_85 = TreeSitter.Node.nodeStartPoint node_83
        TreeSitter.Node.TSPoint
          r2_86
          c2_87 = TreeSitter.Node.nodeEndPoint node_83
  
  deriving instance GHC.Classes.Eq a_88 => GHC.Classes.Eq (AsExprs a_88)
  
  deriving instance GHC.Classes.Ord a_89 => GHC.Classes.Ord (AsExprs a_89)
  
  deriving instance GHC.Show.Show a_90 => GHC.Show.Show (AsExprs a_90)
  
  instance AST.Unmarshal.Unmarshal AsExprs
  
  instance Data.Foldable.Foldable AsExprs where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AsExprs where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AsExprs where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Body a = Body
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_91.
        AST.Traversable1.Class.Traversable1 a_91
      )
  
  instance AST.Unmarshal.SymbolMatching Body where
    matchedSymbols _ = [101]
    showFailure _ node_92 =
      "expected "
        GHC.Base.<> ( "body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_92 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_92) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_93 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_94 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_95 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_96 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_93
          c1_94 = TreeSitter.Node.nodeStartPoint node_92
        TreeSitter.Node.TSPoint
          r2_95
          c2_96 = TreeSitter.Node.nodeEndPoint node_92
  
  deriving instance GHC.Classes.Eq a_97 => GHC.Classes.Eq (Body a_97)
  
  deriving instance GHC.Classes.Ord a_98 => GHC.Classes.Ord (Body a_98)
  
  deriving instance GHC.Show.Show a_99 => GHC.Show.Show (Body a_99)
  
  instance AST.Unmarshal.Unmarshal Body
  
  instance Data.Foldable.Foldable Body where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Body where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Body where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Bool a = Bool
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((False GHC.Generics.:+: True) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_100.
        AST.Traversable1.Class.Traversable1 a_100
      )
  
  instance AST.Unmarshal.SymbolMatching Bool where
    matchedSymbols _ = [132]
    showFailure _ node_101 =
      "expected "
        GHC.Base.<> ( "bool"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_101 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_101) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_102 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_103 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_104 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_105 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_102
          c1_103 = TreeSitter.Node.nodeStartPoint node_101
        TreeSitter.Node.TSPoint
          r2_104
          c2_105 = TreeSitter.Node.nodeEndPoint node_101
  
  deriving instance GHC.Classes.Eq a_106 => GHC.Classes.Eq (Bool a_106)
  
  deriving instance GHC.Classes.Ord a_107 => GHC.Classes.Ord (Bool a_107)
  
  deriving instance GHC.Show.Show a_108 => GHC.Show.Show (Bool a_108)
  
  instance AST.Unmarshal.Unmarshal Bool
  
  instance Data.Foldable.Foldable Bool where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Bool where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Bool where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Charpred a = Charpred
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClassName GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_109.
        AST.Traversable1.Class.Traversable1 a_109
      )
  
  instance AST.Unmarshal.SymbolMatching Charpred where
    matchedSymbols _ = [96]
    showFailure _ node_110 =
      "expected "
        GHC.Base.<> ( "charpred"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_110 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_110) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_111 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_112 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_113 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_114 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_111
          c1_112 = TreeSitter.Node.nodeStartPoint node_110
        TreeSitter.Node.TSPoint
          r2_113
          c2_114 = TreeSitter.Node.nodeEndPoint node_110
  
  deriving instance GHC.Classes.Eq a_115 => GHC.Classes.Eq (Charpred a_115)
  
  deriving instance GHC.Classes.Ord a_116 => GHC.Classes.Ord (Charpred a_116)
  
  deriving instance GHC.Show.Show a_117 => GHC.Show.Show (Charpred a_117)
  
  instance AST.Unmarshal.Unmarshal Charpred
  
  instance Data.Foldable.Foldable Charpred where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Charpred where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Charpred where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassMember a = ClassMember
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: Charpred GHC.Generics.:+: Field GHC.Generics.:+: MemberPredicate GHC.Generics.:+: Qldoc) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_118.
        AST.Traversable1.Class.Traversable1 a_118
      )
  
  instance AST.Unmarshal.SymbolMatching ClassMember where
    matchedSymbols _ = [95]
    showFailure _ node_119 =
      "expected "
        GHC.Base.<> ( "classMember"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_119 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_119) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_120 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_121 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_122 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_123 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_120
          c1_121 = TreeSitter.Node.nodeStartPoint node_119
        TreeSitter.Node.TSPoint
          r2_122
          c2_123 = TreeSitter.Node.nodeEndPoint node_119
  
  deriving instance GHC.Classes.Eq a_124 => GHC.Classes.Eq (ClassMember a_124)
  
  deriving instance GHC.Classes.Ord a_125 => GHC.Classes.Ord (ClassMember a_125)
  
  deriving instance GHC.Show.Show a_126 => GHC.Show.Show (ClassMember a_126)
  
  instance AST.Unmarshal.Unmarshal ClassMember
  
  instance Data.Foldable.Foldable ClassMember where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassMember where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassMember where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassName a = ClassName {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_127.
        AST.Traversable1.Class.Traversable1 a_127
      )
  
  instance AST.Unmarshal.SymbolMatching ClassName where
    matchedSymbols _ = [155]
    showFailure _ node_128 =
      "expected "
        GHC.Base.<> ( "className"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_128 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_128) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_129 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_130 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_131 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_132 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_129
          c1_130 = TreeSitter.Node.nodeStartPoint node_128
        TreeSitter.Node.TSPoint
          r2_131
          c2_132 = TreeSitter.Node.nodeEndPoint node_128
  
  deriving instance GHC.Classes.Eq a_133 => GHC.Classes.Eq (ClassName a_133)
  
  deriving instance GHC.Classes.Ord a_134 => GHC.Classes.Ord (ClassName a_134)
  
  deriving instance GHC.Show.Show a_135 => GHC.Show.Show (ClassName a_135)
  
  instance AST.Unmarshal.Unmarshal ClassName
  
  instance Data.Foldable.Foldable ClassName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClasslessPredicate a = ClasslessPredicate
    { ann :: a,
      name :: (AST.Parse.Err (PredicateName a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Body GHC.Generics.:+: Empty GHC.Generics.:+: HigherOrderTerm GHC.Generics.:+: PredicateAliasBody GHC.Generics.:+: ReturnType GHC.Generics.:+: VarDecl) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_136.
        AST.Traversable1.Class.Traversable1 a_136
      )
  
  instance AST.Unmarshal.SymbolMatching ClasslessPredicate where
    matchedSymbols _ = [89]
    showFailure _ node_137 =
      "expected "
        GHC.Base.<> ( "classlessPredicate"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_137 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_137) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_138 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_139 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_140 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_141 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_138
          c1_139 = TreeSitter.Node.nodeStartPoint node_137
        TreeSitter.Node.TSPoint
          r2_140
          c2_141 = TreeSitter.Node.nodeEndPoint node_137
  
  deriving instance GHC.Classes.Eq a_142 => GHC.Classes.Eq (ClasslessPredicate a_142)
  
  deriving instance GHC.Classes.Ord a_143 => GHC.Classes.Ord (ClasslessPredicate a_143)
  
  deriving instance GHC.Show.Show a_144 => GHC.Show.Show (ClasslessPredicate a_144)
  
  instance AST.Unmarshal.Unmarshal ClasslessPredicate
  
  instance Data.Foldable.Foldable ClasslessPredicate where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClasslessPredicate where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClasslessPredicate where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClasslessPredicateCall a = ClasslessPredicateCall
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: AritylessPredicateExpr GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: Closure GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Underscore GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_145.
        AST.Traversable1.Class.Traversable1 a_145
      )
  
  instance AST.Unmarshal.SymbolMatching ClasslessPredicateCall where
    matchedSymbols _ = [121]
    showFailure _ node_146 =
      "expected "
        GHC.Base.<> ( "classless_predicate_call"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_146 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_146) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_147 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_148 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_149 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_150 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_147
          c1_148 = TreeSitter.Node.nodeStartPoint node_146
        TreeSitter.Node.TSPoint
          r2_149
          c2_150 = TreeSitter.Node.nodeEndPoint node_146
  
  deriving instance GHC.Classes.Eq a_151 => GHC.Classes.Eq (ClasslessPredicateCall a_151)
  
  deriving instance GHC.Classes.Ord a_152 => GHC.Classes.Ord (ClasslessPredicateCall a_152)
  
  deriving instance GHC.Show.Show a_153 => GHC.Show.Show (ClasslessPredicateCall a_153)
  
  instance AST.Unmarshal.Unmarshal ClasslessPredicateCall
  
  instance Data.Foldable.Foldable ClasslessPredicateCall where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClasslessPredicateCall where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClasslessPredicateCall where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Closure a = Closure
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Plus GHC.Generics.:+: Star) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_154.
        AST.Traversable1.Class.Traversable1 a_154
      )
  
  instance AST.Unmarshal.SymbolMatching Closure where
    matchedSymbols _ = [138]
    showFailure _ node_155 =
      "expected "
        GHC.Base.<> ( "closure"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_155 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_155) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_156 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_157 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_158 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_159 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_156
          c1_157 = TreeSitter.Node.nodeStartPoint node_155
        TreeSitter.Node.TSPoint
          r2_158
          c2_159 = TreeSitter.Node.nodeEndPoint node_155
  
  deriving instance GHC.Classes.Eq a_160 => GHC.Classes.Eq (Closure a_160)
  
  deriving instance GHC.Classes.Ord a_161 => GHC.Classes.Ord (Closure a_161)
  
  deriving instance GHC.Show.Show a_162 => GHC.Show.Show (Closure a_162)
  
  instance AST.Unmarshal.Unmarshal Closure
  
  instance Data.Foldable.Foldable Closure where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Closure where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Closure where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CompTerm a = CompTerm
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      extraChildren :: (AST.Parse.Err (Compop a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_163.
        AST.Traversable1.Class.Traversable1 a_163
      )
  
  instance AST.Unmarshal.SymbolMatching CompTerm where
    matchedSymbols _ = [109]
    showFailure _ node_164 =
      "expected "
        GHC.Base.<> ( "comp_term"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_164 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_164) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_165 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_166 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_167 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_168 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_165
          c1_166 = TreeSitter.Node.nodeStartPoint node_164
        TreeSitter.Node.TSPoint
          r2_167
          c2_168 = TreeSitter.Node.nodeEndPoint node_164
  
  deriving instance GHC.Classes.Eq a_169 => GHC.Classes.Eq (CompTerm a_169)
  
  deriving instance GHC.Classes.Ord a_170 => GHC.Classes.Ord (CompTerm a_170)
  
  deriving instance GHC.Show.Show a_171 => GHC.Show.Show (CompTerm a_171)
  
  instance AST.Unmarshal.Unmarshal CompTerm
  
  instance Data.Foldable.Foldable CompTerm where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CompTerm where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CompTerm where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Compop a = Compop
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Eq GHC.Generics.:+: Ge GHC.Generics.:+: Gt GHC.Generics.:+: Le GHC.Generics.:+: Lt GHC.Generics.:+: Ne) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_172.
        AST.Traversable1.Class.Traversable1 a_172
      )
  
  instance AST.Unmarshal.SymbolMatching Compop where
    matchedSymbols _ = [134]
    showFailure _ node_173 =
      "expected "
        GHC.Base.<> ( "compop"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_173 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_173) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_174 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_175 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_176 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_177 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_174
          c1_175 = TreeSitter.Node.nodeStartPoint node_173
        TreeSitter.Node.TSPoint
          r2_176
          c2_177 = TreeSitter.Node.nodeEndPoint node_173
  
  deriving instance GHC.Classes.Eq a_178 => GHC.Classes.Eq (Compop a_178)
  
  deriving instance GHC.Classes.Ord a_179 => GHC.Classes.Ord (Compop a_179)
  
  deriving instance GHC.Show.Show a_180 => GHC.Show.Show (Compop a_180)
  
  instance AST.Unmarshal.Unmarshal Compop
  
  instance Data.Foldable.Foldable Compop where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Compop where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Compop where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Conjunction a = Conjunction
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_181.
        AST.Traversable1.Class.Traversable1 a_181
      )
  
  instance AST.Unmarshal.SymbolMatching Conjunction where
    matchedSymbols _ = [113]
    showFailure _ node_182 =
      "expected "
        GHC.Base.<> ( "conjunction"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_182 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_182) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_183 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_184 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_185 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_186 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_183
          c1_184 = TreeSitter.Node.nodeStartPoint node_182
        TreeSitter.Node.TSPoint
          r2_185
          c2_186 = TreeSitter.Node.nodeEndPoint node_182
  
  deriving instance GHC.Classes.Eq a_187 => GHC.Classes.Eq (Conjunction a_187)
  
  deriving instance GHC.Classes.Ord a_188 => GHC.Classes.Ord (Conjunction a_188)
  
  deriving instance GHC.Show.Show a_189 => GHC.Show.Show (Conjunction a_189)
  
  instance AST.Unmarshal.Unmarshal Conjunction
  
  instance Data.Foldable.Foldable Conjunction where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Conjunction where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Conjunction where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Dataclass a = Dataclass
    { ann :: a,
      name :: (AST.Parse.Err (ClassName a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Class GHC.Generics.:+: ClassMember GHC.Generics.:+: Extends GHC.Generics.:+: TypeAliasBody GHC.Generics.:+: TypeExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_190.
        AST.Traversable1.Class.Traversable1 a_190
      )
  
  instance AST.Unmarshal.SymbolMatching Dataclass where
    matchedSymbols _ = [94]
    showFailure _ node_191 =
      "expected "
        GHC.Base.<> ( "dataclass"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_191 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_191) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_192 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_193 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_194 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_195 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_192
          c1_193 = TreeSitter.Node.nodeStartPoint node_191
        TreeSitter.Node.TSPoint
          r2_194
          c2_195 = TreeSitter.Node.nodeEndPoint node_191
  
  deriving instance GHC.Classes.Eq a_196 => GHC.Classes.Eq (Dataclass a_196)
  
  deriving instance GHC.Classes.Ord a_197 => GHC.Classes.Ord (Dataclass a_197)
  
  deriving instance GHC.Show.Show a_198 => GHC.Show.Show (Dataclass a_198)
  
  instance AST.Unmarshal.Unmarshal Dataclass
  
  instance Data.Foldable.Foldable Dataclass where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Dataclass where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Dataclass where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Datatype a = Datatype
    { ann :: a,
      name :: (AST.Parse.Err (ClassName a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((DatatypeBranches GHC.Generics.:+: Eq GHC.Generics.:+: Newtype) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_199.
        AST.Traversable1.Class.Traversable1 a_199
      )
  
  instance AST.Unmarshal.SymbolMatching Datatype where
    matchedSymbols _ = [90]
    showFailure _ node_200 =
      "expected "
        GHC.Base.<> ( "datatype"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_200 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_200) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_201 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_202 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_203 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_204 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_201
          c1_202 = TreeSitter.Node.nodeStartPoint node_200
        TreeSitter.Node.TSPoint
          r2_203
          c2_204 = TreeSitter.Node.nodeEndPoint node_200
  
  deriving instance GHC.Classes.Eq a_205 => GHC.Classes.Eq (Datatype a_205)
  
  deriving instance GHC.Classes.Ord a_206 => GHC.Classes.Ord (Datatype a_206)
  
  deriving instance GHC.Show.Show a_207 => GHC.Show.Show (Datatype a_207)
  
  instance AST.Unmarshal.Unmarshal Datatype
  
  instance Data.Foldable.Foldable Datatype where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Datatype where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Datatype where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DatatypeBranch a = DatatypeBranch
    { ann :: a,
      name :: (AST.Parse.Err (ClassName a)),
      extraChildren :: ([AST.Parse.Err ((Annotation GHC.Generics.:+: Body GHC.Generics.:+: Qldoc GHC.Generics.:+: VarDecl) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_208.
        AST.Traversable1.Class.Traversable1 a_208
      )
  
  instance AST.Unmarshal.SymbolMatching DatatypeBranch where
    matchedSymbols _ = [92]
    showFailure _ node_209 =
      "expected "
        GHC.Base.<> ( "datatypeBranch"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_209 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_209) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_210 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_211 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_212 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_213 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_210
          c1_211 = TreeSitter.Node.nodeStartPoint node_209
        TreeSitter.Node.TSPoint
          r2_212
          c2_213 = TreeSitter.Node.nodeEndPoint node_209
  
  deriving instance GHC.Classes.Eq a_214 => GHC.Classes.Eq (DatatypeBranch a_214)
  
  deriving instance GHC.Classes.Ord a_215 => GHC.Classes.Ord (DatatypeBranch a_215)
  
  deriving instance GHC.Show.Show a_216 => GHC.Show.Show (DatatypeBranch a_216)
  
  instance AST.Unmarshal.Unmarshal DatatypeBranch
  
  instance Data.Foldable.Foldable DatatypeBranch where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DatatypeBranch where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DatatypeBranch where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DatatypeBranches a = DatatypeBranches
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (DatatypeBranch a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_217.
        AST.Traversable1.Class.Traversable1 a_217
      )
  
  instance AST.Unmarshal.SymbolMatching DatatypeBranches where
    matchedSymbols _ = [91]
    showFailure _ node_218 =
      "expected "
        GHC.Base.<> ( "datatypeBranches"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_218 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_218) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_219 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_220 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_221 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_222 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_219
          c1_220 = TreeSitter.Node.nodeStartPoint node_218
        TreeSitter.Node.TSPoint
          r2_221
          c2_222 = TreeSitter.Node.nodeEndPoint node_218
  
  deriving instance GHC.Classes.Eq a_223 => GHC.Classes.Eq (DatatypeBranches a_223)
  
  deriving instance GHC.Classes.Ord a_224 => GHC.Classes.Ord (DatatypeBranches a_224)
  
  deriving instance GHC.Show.Show a_225 => GHC.Show.Show (DatatypeBranches a_225)
  
  instance AST.Unmarshal.Unmarshal DatatypeBranches
  
  instance Data.Foldable.Foldable DatatypeBranches where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DatatypeBranches where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DatatypeBranches where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Dbtype a = Dbtype {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_226.
        AST.Traversable1.Class.Traversable1 a_226
      )
  
  instance AST.Unmarshal.SymbolMatching Dbtype where
    matchedSymbols _ = [156]
    showFailure _ node_227 =
      "expected "
        GHC.Base.<> ( "dbtype"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_227 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_227) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_228 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_229 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_230 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_231 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_228
          c1_229 = TreeSitter.Node.nodeStartPoint node_227
        TreeSitter.Node.TSPoint
          r2_230
          c2_231 = TreeSitter.Node.nodeEndPoint node_227
  
  deriving instance GHC.Classes.Eq a_232 => GHC.Classes.Eq (Dbtype a_232)
  
  deriving instance GHC.Classes.Ord a_233 => GHC.Classes.Ord (Dbtype a_233)
  
  deriving instance GHC.Show.Show a_234 => GHC.Show.Show (Dbtype a_234)
  
  instance AST.Unmarshal.Unmarshal Dbtype
  
  instance Data.Foldable.Foldable Dbtype where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Dbtype where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Dbtype where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Direction a = Direction
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Asc GHC.Generics.:+: Desc) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_235.
        AST.Traversable1.Class.Traversable1 a_235
      )
  
  instance AST.Unmarshal.SymbolMatching Direction where
    matchedSymbols _ = [139]
    showFailure _ node_236 =
      "expected "
        GHC.Base.<> ( "direction"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_236 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_236) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_237 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_238 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_239 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_240 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_237
          c1_238 = TreeSitter.Node.nodeStartPoint node_236
        TreeSitter.Node.TSPoint
          r2_239
          c2_240 = TreeSitter.Node.nodeEndPoint node_236
  
  deriving instance GHC.Classes.Eq a_241 => GHC.Classes.Eq (Direction a_241)
  
  deriving instance GHC.Classes.Ord a_242 => GHC.Classes.Ord (Direction a_242)
  
  deriving instance GHC.Show.Show a_243 => GHC.Show.Show (Direction a_243)
  
  instance AST.Unmarshal.Unmarshal Direction
  
  instance Data.Foldable.Foldable Direction where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Direction where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Direction where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Disjunction a = Disjunction
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_244.
        AST.Traversable1.Class.Traversable1 a_244
      )
  
  instance AST.Unmarshal.SymbolMatching Disjunction where
    matchedSymbols _ = [114]
    showFailure _ node_245 =
      "expected "
        GHC.Base.<> ( "disjunction"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_245 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_245) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_246 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_247 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_248 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_249 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_246
          c1_247 = TreeSitter.Node.nodeStartPoint node_245
        TreeSitter.Node.TSPoint
          r2_248
          c2_249 = TreeSitter.Node.nodeEndPoint node_245
  
  deriving instance GHC.Classes.Eq a_250 => GHC.Classes.Eq (Disjunction a_250)
  
  deriving instance GHC.Classes.Ord a_251 => GHC.Classes.Ord (Disjunction a_251)
  
  deriving instance GHC.Show.Show a_252 => GHC.Show.Show (Disjunction a_252)
  
  instance AST.Unmarshal.Unmarshal Disjunction
  
  instance Data.Foldable.Foldable Disjunction where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Disjunction where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Disjunction where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Empty a = Empty {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_253.
        AST.Traversable1.Class.Traversable1 a_253
      )
  
  instance AST.Unmarshal.SymbolMatching Empty where
    matchedSymbols _ = [100]
    showFailure _ node_254 =
      "expected "
        GHC.Base.<> ( "empty"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_254 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_254) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_255 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_256 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_257 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_258 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_255
          c1_256 = TreeSitter.Node.nodeStartPoint node_254
        TreeSitter.Node.TSPoint
          r2_257
          c2_258 = TreeSitter.Node.nodeEndPoint node_254
  
  deriving instance GHC.Classes.Eq a_259 => GHC.Classes.Eq (Empty a_259)
  
  deriving instance GHC.Classes.Ord a_260 => GHC.Classes.Ord (Empty a_260)
  
  deriving instance GHC.Show.Show a_261 => GHC.Show.Show (Empty a_261)
  
  instance AST.Unmarshal.Unmarshal Empty
  
  instance Data.Foldable.Foldable Empty where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Empty where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Empty where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExprAggregateBody a = ExprAggregateBody
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AsExprs GHC.Generics.:+: OrderBys) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_262.
        AST.Traversable1.Class.Traversable1 a_262
      )
  
  instance AST.Unmarshal.SymbolMatching ExprAggregateBody where
    matchedSymbols _ = [125]
    showFailure _ node_263 =
      "expected "
        GHC.Base.<> ( "expr_aggregate_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_263 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_263) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_264 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_265 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_266 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_267 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_264
          c1_265 = TreeSitter.Node.nodeStartPoint node_263
        TreeSitter.Node.TSPoint
          r2_266
          c2_267 = TreeSitter.Node.nodeEndPoint node_263
  
  deriving instance GHC.Classes.Eq a_268 => GHC.Classes.Eq (ExprAggregateBody a_268)
  
  deriving instance GHC.Classes.Ord a_269 => GHC.Classes.Ord (ExprAggregateBody a_269)
  
  deriving instance GHC.Show.Show a_270 => GHC.Show.Show (ExprAggregateBody a_270)
  
  instance AST.Unmarshal.Unmarshal ExprAggregateBody
  
  instance Data.Foldable.Foldable ExprAggregateBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExprAggregateBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExprAggregateBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Field a = Field {ann :: a, extraChildren :: (AST.Parse.Err (VarDecl a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_271.
        AST.Traversable1.Class.Traversable1 a_271
      )
  
  instance AST.Unmarshal.SymbolMatching Field where
    matchedSymbols _ = [98]
    showFailure _ node_272 =
      "expected "
        GHC.Base.<> ( "field"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_272 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_272) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_273 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_274 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_275 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_276 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_273
          c1_274 = TreeSitter.Node.nodeStartPoint node_272
        TreeSitter.Node.TSPoint
          r2_275
          c2_276 = TreeSitter.Node.nodeEndPoint node_272
  
  deriving instance GHC.Classes.Eq a_277 => GHC.Classes.Eq (Field a_277)
  
  deriving instance GHC.Classes.Ord a_278 => GHC.Classes.Ord (Field a_278)
  
  deriving instance GHC.Show.Show a_279 => GHC.Show.Show (Field a_279)
  
  instance AST.Unmarshal.Unmarshal Field
  
  instance Data.Foldable.Foldable Field where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Field where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Field where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FullAggregateBody a = FullAggregateBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: AsExprs GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: OrderBys GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: VarDecl GHC.Generics.:+: Variable) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_280.
        AST.Traversable1.Class.Traversable1 a_280
      )
  
  instance AST.Unmarshal.SymbolMatching FullAggregateBody where
    matchedSymbols _ = [124]
    showFailure _ node_281 =
      "expected "
        GHC.Base.<> ( "full_aggregate_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_281 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_281) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_282 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_283 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_284 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_285 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_282
          c1_283 = TreeSitter.Node.nodeStartPoint node_281
        TreeSitter.Node.TSPoint
          r2_284
          c2_285 = TreeSitter.Node.nodeEndPoint node_281
  
  deriving instance GHC.Classes.Eq a_286 => GHC.Classes.Eq (FullAggregateBody a_286)
  
  deriving instance GHC.Classes.Ord a_287 => GHC.Classes.Ord (FullAggregateBody a_287)
  
  deriving instance GHC.Show.Show a_288 => GHC.Show.Show (FullAggregateBody a_288)
  
  instance AST.Unmarshal.Unmarshal FullAggregateBody
  
  instance Data.Foldable.Foldable FullAggregateBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FullAggregateBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FullAggregateBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HigherOrderTerm a = HigherOrderTerm
    { ann :: a,
      name :: (AST.Parse.Err (LiteralId a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: Eq GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PredicateExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Underscore GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_289.
        AST.Traversable1.Class.Traversable1 a_289
      )
  
  instance AST.Unmarshal.SymbolMatching HigherOrderTerm where
    matchedSymbols _ = [102]
    showFailure _ node_290 =
      "expected "
        GHC.Base.<> ( "higherOrderTerm"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_290 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_290) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_291 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_292 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_293 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_294 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_291
          c1_292 = TreeSitter.Node.nodeStartPoint node_290
        TreeSitter.Node.TSPoint
          r2_293
          c2_294 = TreeSitter.Node.nodeEndPoint node_290
  
  deriving instance GHC.Classes.Eq a_295 => GHC.Classes.Eq (HigherOrderTerm a_295)
  
  deriving instance GHC.Classes.Ord a_296 => GHC.Classes.Ord (HigherOrderTerm a_296)
  
  deriving instance GHC.Show.Show a_297 => GHC.Show.Show (HigherOrderTerm a_297)
  
  instance AST.Unmarshal.Unmarshal HigherOrderTerm
  
  instance Data.Foldable.Foldable HigherOrderTerm where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HigherOrderTerm where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HigherOrderTerm where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfTerm a = IfTerm
    { ann :: a,
      first :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      second :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      cond :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_298.
        AST.Traversable1.Class.Traversable1 a_298
      )
  
  instance AST.Unmarshal.SymbolMatching IfTerm where
    matchedSymbols _ = [112]
    showFailure _ node_299 =
      "expected "
        GHC.Base.<> ( "if_term"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_299 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_299) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_300 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_301 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_302 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_303 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_300
          c1_301 = TreeSitter.Node.nodeStartPoint node_299
        TreeSitter.Node.TSPoint
          r2_302
          c2_303 = TreeSitter.Node.nodeEndPoint node_299
  
  deriving instance GHC.Classes.Eq a_304 => GHC.Classes.Eq (IfTerm a_304)
  
  deriving instance GHC.Classes.Ord a_305 => GHC.Classes.Ord (IfTerm a_305)
  
  deriving instance GHC.Show.Show a_306 => GHC.Show.Show (IfTerm a_306)
  
  instance AST.Unmarshal.Unmarshal IfTerm
  
  instance Data.Foldable.Foldable IfTerm where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IfTerm where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IfTerm where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Implication a = Implication
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_307.
        AST.Traversable1.Class.Traversable1 a_307
      )
  
  instance AST.Unmarshal.SymbolMatching Implication where
    matchedSymbols _ = [115]
    showFailure _ node_308 =
      "expected "
        GHC.Base.<> ( "implication"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_308 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_308) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_309 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_310 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_311 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_312 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_309
          c1_310 = TreeSitter.Node.nodeStartPoint node_308
        TreeSitter.Node.TSPoint
          r2_311
          c2_312 = TreeSitter.Node.nodeEndPoint node_308
  
  deriving instance GHC.Classes.Eq a_313 => GHC.Classes.Eq (Implication a_313)
  
  deriving instance GHC.Classes.Ord a_314 => GHC.Classes.Ord (Implication a_314)
  
  deriving instance GHC.Show.Show a_315 => GHC.Show.Show (Implication a_315)
  
  instance AST.Unmarshal.Unmarshal Implication
  
  instance Data.Foldable.Foldable Implication where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Implication where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Implication where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ImportModuleExpr a = ImportModuleExpr
    { ann :: a,
      name :: ([AST.Parse.Err (SimpleId a)]),
      extraChildren :: (AST.Parse.Err (QualModuleExpr a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_316.
        AST.Traversable1.Class.Traversable1 a_316
      )
  
  instance AST.Unmarshal.SymbolMatching ImportModuleExpr where
    matchedSymbols _ = [151]
    showFailure _ node_317 =
      "expected "
        GHC.Base.<> ( "importModuleExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_317 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_317) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_318 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_319 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_320 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_321 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_318
          c1_319 = TreeSitter.Node.nodeStartPoint node_317
        TreeSitter.Node.TSPoint
          r2_320
          c2_321 = TreeSitter.Node.nodeEndPoint node_317
  
  deriving instance GHC.Classes.Eq a_322 => GHC.Classes.Eq (ImportModuleExpr a_322)
  
  deriving instance GHC.Classes.Ord a_323 => GHC.Classes.Ord (ImportModuleExpr a_323)
  
  deriving instance GHC.Show.Show a_324 => GHC.Show.Show (ImportModuleExpr a_324)
  
  instance AST.Unmarshal.Unmarshal ImportModuleExpr
  
  instance Data.Foldable.Foldable ImportModuleExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ImportModuleExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ImportModuleExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Imprt a = Imprt
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((As GHC.Generics.:+: Import GHC.Generics.:+: ImportModuleExpr GHC.Generics.:+: ModuleName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_325.
        AST.Traversable1.Class.Traversable1 a_325
      )
  
  instance AST.Unmarshal.SymbolMatching Imprt where
    matchedSymbols _ = [85]
    showFailure _ node_326 =
      "expected "
        GHC.Base.<> ( "imprt"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_326 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_326) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_327 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_328 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_329 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_330 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_327
          c1_328 = TreeSitter.Node.nodeStartPoint node_326
        TreeSitter.Node.TSPoint
          r2_329
          c2_330 = TreeSitter.Node.nodeEndPoint node_326
  
  deriving instance GHC.Classes.Eq a_331 => GHC.Classes.Eq (Imprt a_331)
  
  deriving instance GHC.Classes.Ord a_332 => GHC.Classes.Ord (Imprt a_332)
  
  deriving instance GHC.Show.Show a_333 => GHC.Show.Show (Imprt a_333)
  
  instance AST.Unmarshal.Unmarshal Imprt
  
  instance Data.Foldable.Foldable Imprt where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Imprt where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Imprt where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InExpr a = InExpr
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err (Range a)),
      extraChildren :: (AST.Parse.Err (In a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_334.
        AST.Traversable1.Class.Traversable1 a_334
      )
  
  instance AST.Unmarshal.SymbolMatching InExpr where
    matchedSymbols _ = [108]
    showFailure _ node_335 =
      "expected "
        GHC.Base.<> ( "in_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_335 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_335) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_336 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_337 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_338 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_339 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_336
          c1_337 = TreeSitter.Node.nodeStartPoint node_335
        TreeSitter.Node.TSPoint
          r2_338
          c2_339 = TreeSitter.Node.nodeEndPoint node_335
  
  deriving instance GHC.Classes.Eq a_340 => GHC.Classes.Eq (InExpr a_340)
  
  deriving instance GHC.Classes.Ord a_341 => GHC.Classes.Ord (InExpr a_341)
  
  deriving instance GHC.Show.Show a_342 => GHC.Show.Show (InExpr a_342)
  
  instance AST.Unmarshal.Unmarshal InExpr
  
  instance Data.Foldable.Foldable InExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InstanceOf a = InstanceOf
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Instanceof GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: TypeExpr GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_343.
        AST.Traversable1.Class.Traversable1 a_343
      )
  
  instance AST.Unmarshal.SymbolMatching InstanceOf where
    matchedSymbols _ = [110]
    showFailure _ node_344 =
      "expected "
        GHC.Base.<> ( "instance_of"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_344 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_344) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_345 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_346 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_347 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_348 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_345
          c1_346 = TreeSitter.Node.nodeStartPoint node_344
        TreeSitter.Node.TSPoint
          r2_347
          c2_348 = TreeSitter.Node.nodeEndPoint node_344
  
  deriving instance GHC.Classes.Eq a_349 => GHC.Classes.Eq (InstanceOf a_349)
  
  deriving instance GHC.Classes.Ord a_350 => GHC.Classes.Ord (InstanceOf a_350)
  
  deriving instance GHC.Show.Show a_351 => GHC.Show.Show (InstanceOf a_351)
  
  instance AST.Unmarshal.Unmarshal InstanceOf
  
  instance Data.Foldable.Foldable InstanceOf where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InstanceOf where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InstanceOf where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Literal a = Literal
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Bool GHC.Generics.:+: Float GHC.Generics.:+: Integer GHC.Generics.:+: String) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_352.
        AST.Traversable1.Class.Traversable1 a_352
      )
  
  instance AST.Unmarshal.SymbolMatching Literal where
    matchedSymbols _ = [131]
    showFailure _ node_353 =
      "expected "
        GHC.Base.<> ( "literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_353 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_353) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_354 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_355 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_356 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_357 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_354
          c1_355 = TreeSitter.Node.nodeStartPoint node_353
        TreeSitter.Node.TSPoint
          r2_356
          c2_357 = TreeSitter.Node.nodeEndPoint node_353
  
  deriving instance GHC.Classes.Eq a_358 => GHC.Classes.Eq (Literal a_358)
  
  deriving instance GHC.Classes.Ord a_359 => GHC.Classes.Ord (Literal a_359)
  
  deriving instance GHC.Show.Show a_360 => GHC.Show.Show (Literal a_360)
  
  instance AST.Unmarshal.Unmarshal Literal
  
  instance Data.Foldable.Foldable Literal where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Literal where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Literal where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LiteralId a = LiteralId {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_361.
        AST.Traversable1.Class.Traversable1 a_361
      )
  
  instance AST.Unmarshal.SymbolMatching LiteralId where
    matchedSymbols _ = [145]
    showFailure _ node_362 =
      "expected "
        GHC.Base.<> ( "literalId"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_362 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_362) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_363 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_364 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_365 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_366 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_363
          c1_364 = TreeSitter.Node.nodeStartPoint node_362
        TreeSitter.Node.TSPoint
          r2_365
          c2_366 = TreeSitter.Node.nodeEndPoint node_362
  
  deriving instance GHC.Classes.Eq a_367 => GHC.Classes.Eq (LiteralId a_367)
  
  deriving instance GHC.Classes.Ord a_368 => GHC.Classes.Ord (LiteralId a_368)
  
  deriving instance GHC.Show.Show a_369 => GHC.Show.Show (LiteralId a_369)
  
  instance AST.Unmarshal.Unmarshal LiteralId
  
  instance Data.Foldable.Foldable LiteralId where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LiteralId where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LiteralId where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MemberPredicate a = MemberPredicate
    { ann :: a,
      name :: (AST.Parse.Err (PredicateName a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Body GHC.Generics.:+: Empty GHC.Generics.:+: HigherOrderTerm GHC.Generics.:+: ReturnType GHC.Generics.:+: VarDecl) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_370.
        AST.Traversable1.Class.Traversable1 a_370
      )
  
  instance AST.Unmarshal.SymbolMatching MemberPredicate where
    matchedSymbols _ = [97]
    showFailure _ node_371 =
      "expected "
        GHC.Base.<> ( "memberPredicate"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_371 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_371) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_372 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_373 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_374 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_375 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_372
          c1_373 = TreeSitter.Node.nodeStartPoint node_371
        TreeSitter.Node.TSPoint
          r2_374
          c2_375 = TreeSitter.Node.nodeEndPoint node_371
  
  deriving instance GHC.Classes.Eq a_376 => GHC.Classes.Eq (MemberPredicate a_376)
  
  deriving instance GHC.Classes.Ord a_377 => GHC.Classes.Ord (MemberPredicate a_377)
  
  deriving instance GHC.Show.Show a_378 => GHC.Show.Show (MemberPredicate a_378)
  
  instance AST.Unmarshal.Unmarshal MemberPredicate
  
  instance Data.Foldable.Foldable MemberPredicate where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MemberPredicate where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MemberPredicate where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Module a = Module
    { ann :: a,
      name :: (AST.Parse.Err (ModuleName a)),
      extraChildren :: ([AST.Parse.Err ((ModuleAliasBody GHC.Generics.:+: ModuleMember) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_379.
        AST.Traversable1.Class.Traversable1 a_379
      )
  
  instance AST.Unmarshal.SymbolMatching Module where
    matchedSymbols _ = [83]
    showFailure _ node_380 =
      "expected "
        GHC.Base.<> ( "module"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_380 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_380) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_381 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_382 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_383 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_384 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_381
          c1_382 = TreeSitter.Node.nodeStartPoint node_380
        TreeSitter.Node.TSPoint
          r2_383
          c2_384 = TreeSitter.Node.nodeEndPoint node_380
  
  deriving instance GHC.Classes.Eq a_385 => GHC.Classes.Eq (Module a_385)
  
  deriving instance GHC.Classes.Ord a_386 => GHC.Classes.Ord (Module a_386)
  
  deriving instance GHC.Show.Show a_387 => GHC.Show.Show (Module a_387)
  
  instance AST.Unmarshal.Unmarshal Module
  
  instance Data.Foldable.Foldable Module where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Module where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Module where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleAliasBody a = ModuleAliasBody
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Eq GHC.Generics.:+: ModuleExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_388.
        AST.Traversable1.Class.Traversable1 a_388
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleAliasBody where
    matchedSymbols _ = [86]
    showFailure _ node_389 =
      "expected "
        GHC.Base.<> ( "moduleAliasBody"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_389 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_389) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_390 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_391 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_392 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_393 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_390
          c1_391 = TreeSitter.Node.nodeStartPoint node_389
        TreeSitter.Node.TSPoint
          r2_392
          c2_393 = TreeSitter.Node.nodeEndPoint node_389
  
  deriving instance GHC.Classes.Eq a_394 => GHC.Classes.Eq (ModuleAliasBody a_394)
  
  deriving instance GHC.Classes.Ord a_395 => GHC.Classes.Ord (ModuleAliasBody a_395)
  
  deriving instance GHC.Show.Show a_396 => GHC.Show.Show (ModuleAliasBody a_396)
  
  instance AST.Unmarshal.Unmarshal ModuleAliasBody
  
  instance Data.Foldable.Foldable ModuleAliasBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleAliasBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleAliasBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleExpr a = ModuleExpr
    { ann :: a,
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (SimpleId a))),
      extraChildren :: (AST.Parse.Err ((ModuleExpr GHC.Generics.:+: SimpleId) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_397.
        AST.Traversable1.Class.Traversable1 a_397
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleExpr where
    matchedSymbols _ = [152]
    showFailure _ node_398 =
      "expected "
        GHC.Base.<> ( "moduleExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_398 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_398) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_399 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_400 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_401 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_402 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_399
          c1_400 = TreeSitter.Node.nodeStartPoint node_398
        TreeSitter.Node.TSPoint
          r2_401
          c2_402 = TreeSitter.Node.nodeEndPoint node_398
  
  deriving instance GHC.Classes.Eq a_403 => GHC.Classes.Eq (ModuleExpr a_403)
  
  deriving instance GHC.Classes.Ord a_404 => GHC.Classes.Ord (ModuleExpr a_404)
  
  deriving instance GHC.Show.Show a_405 => GHC.Show.Show (ModuleExpr a_405)
  
  instance AST.Unmarshal.Unmarshal ModuleExpr
  
  instance Data.Foldable.Foldable ModuleExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleMember a = ModuleMember
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: ClasslessPredicate GHC.Generics.:+: Dataclass GHC.Generics.:+: Datatype GHC.Generics.:+: Imprt GHC.Generics.:+: Module GHC.Generics.:+: Qldoc GHC.Generics.:+: Select) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_406.
        AST.Traversable1.Class.Traversable1 a_406
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleMember where
    matchedSymbols _ = [84]
    showFailure _ node_407 =
      "expected "
        GHC.Base.<> ( "moduleMember"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_407 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_407) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_408 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_409 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_410 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_411 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_408
          c1_409 = TreeSitter.Node.nodeStartPoint node_407
        TreeSitter.Node.TSPoint
          r2_410
          c2_411 = TreeSitter.Node.nodeEndPoint node_407
  
  deriving instance GHC.Classes.Eq a_412 => GHC.Classes.Eq (ModuleMember a_412)
  
  deriving instance GHC.Classes.Ord a_413 => GHC.Classes.Ord (ModuleMember a_413)
  
  deriving instance GHC.Show.Show a_414 => GHC.Show.Show (ModuleMember a_414)
  
  instance AST.Unmarshal.Unmarshal ModuleMember
  
  instance Data.Foldable.Foldable ModuleMember where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleMember where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleMember where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleName a = ModuleName
    { ann :: a,
      extraChildren :: (AST.Parse.Err (SimpleId a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_415.
        AST.Traversable1.Class.Traversable1 a_415
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleName where
    matchedSymbols _ = [149]
    showFailure _ node_416 =
      "expected "
        GHC.Base.<> ( "moduleName"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_416 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_416) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_417 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_418 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_419 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_420 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_417
          c1_418 = TreeSitter.Node.nodeStartPoint node_416
        TreeSitter.Node.TSPoint
          r2_419
          c2_420 = TreeSitter.Node.nodeEndPoint node_416
  
  deriving instance GHC.Classes.Eq a_421 => GHC.Classes.Eq (ModuleName a_421)
  
  deriving instance GHC.Classes.Ord a_422 => GHC.Classes.Ord (ModuleName a_422)
  
  deriving instance GHC.Show.Show a_423 => GHC.Show.Show (ModuleName a_423)
  
  instance AST.Unmarshal.Unmarshal ModuleName
  
  instance Data.Foldable.Foldable ModuleName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MulExpr a = MulExpr
    { ann :: a,
      left :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      right :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      extraChildren :: (AST.Parse.Err (Mulop a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_424.
        AST.Traversable1.Class.Traversable1 a_424
      )
  
  instance AST.Unmarshal.SymbolMatching MulExpr where
    matchedSymbols _ = [106]
    showFailure _ node_425 =
      "expected "
        GHC.Base.<> ( "mul_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_425 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_425) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_426 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_427 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_428 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_429 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_426
          c1_427 = TreeSitter.Node.nodeStartPoint node_425
        TreeSitter.Node.TSPoint
          r2_428
          c2_429 = TreeSitter.Node.nodeEndPoint node_425
  
  deriving instance GHC.Classes.Eq a_430 => GHC.Classes.Eq (MulExpr a_430)
  
  deriving instance GHC.Classes.Ord a_431 => GHC.Classes.Ord (MulExpr a_431)
  
  deriving instance GHC.Show.Show a_432 => GHC.Show.Show (MulExpr a_432)
  
  instance AST.Unmarshal.Unmarshal MulExpr
  
  instance Data.Foldable.Foldable MulExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MulExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MulExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Mulop a = Mulop
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Mod GHC.Generics.:+: Slash GHC.Generics.:+: Star) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_433.
        AST.Traversable1.Class.Traversable1 a_433
      )
  
  instance AST.Unmarshal.SymbolMatching Mulop where
    matchedSymbols _ = [136]
    showFailure _ node_434 =
      "expected "
        GHC.Base.<> ( "mulop"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_434 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_434) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_435 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_436 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_437 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_438 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_435
          c1_436 = TreeSitter.Node.nodeStartPoint node_434
        TreeSitter.Node.TSPoint
          r2_437
          c2_438 = TreeSitter.Node.nodeEndPoint node_434
  
  deriving instance GHC.Classes.Eq a_439 => GHC.Classes.Eq (Mulop a_439)
  
  deriving instance GHC.Classes.Ord a_440 => GHC.Classes.Ord (Mulop a_440)
  
  deriving instance GHC.Show.Show a_441 => GHC.Show.Show (Mulop a_441)
  
  instance AST.Unmarshal.Unmarshal Mulop
  
  instance Data.Foldable.Foldable Mulop where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Mulop where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Mulop where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Negation a = Negation
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: Not GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_442.
        AST.Traversable1.Class.Traversable1 a_442
      )
  
  instance AST.Unmarshal.SymbolMatching Negation where
    matchedSymbols _ = [111]
    showFailure _ node_443 =
      "expected "
        GHC.Base.<> ( "negation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_443 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_443) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_444 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_445 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_446 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_447 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_444
          c1_445 = TreeSitter.Node.nodeStartPoint node_443
        TreeSitter.Node.TSPoint
          r2_446
          c2_447 = TreeSitter.Node.nodeEndPoint node_443
  
  deriving instance GHC.Classes.Eq a_448 => GHC.Classes.Eq (Negation a_448)
  
  deriving instance GHC.Classes.Ord a_449 => GHC.Classes.Ord (Negation a_449)
  
  deriving instance GHC.Show.Show a_450 => GHC.Show.Show (Negation a_450)
  
  instance AST.Unmarshal.Unmarshal Negation
  
  instance Data.Foldable.Foldable Negation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Negation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Negation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data OrderBy a = OrderBy
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Direction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_451.
        AST.Traversable1.Class.Traversable1 a_451
      )
  
  instance AST.Unmarshal.SymbolMatching OrderBy where
    matchedSymbols _ = [144]
    showFailure _ node_452 =
      "expected "
        GHC.Base.<> ( "orderBy"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_452 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_452) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_453 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_454 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_455 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_456 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_453
          c1_454 = TreeSitter.Node.nodeStartPoint node_452
        TreeSitter.Node.TSPoint
          r2_455
          c2_456 = TreeSitter.Node.nodeEndPoint node_452
  
  deriving instance GHC.Classes.Eq a_457 => GHC.Classes.Eq (OrderBy a_457)
  
  deriving instance GHC.Classes.Ord a_458 => GHC.Classes.Ord (OrderBy a_458)
  
  deriving instance GHC.Show.Show a_459 => GHC.Show.Show (OrderBy a_459)
  
  instance AST.Unmarshal.Unmarshal OrderBy
  
  instance Data.Foldable.Foldable OrderBy where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OrderBy where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OrderBy where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data OrderBys a = OrderBys
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (OrderBy a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_460.
        AST.Traversable1.Class.Traversable1 a_460
      )
  
  instance AST.Unmarshal.SymbolMatching OrderBys where
    matchedSymbols _ = [143]
    showFailure _ node_461 =
      "expected "
        GHC.Base.<> ( "orderBys"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_461 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_461) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_462 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_463 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_464 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_465 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_462
          c1_463 = TreeSitter.Node.nodeStartPoint node_461
        TreeSitter.Node.TSPoint
          r2_464
          c2_465 = TreeSitter.Node.nodeEndPoint node_461
  
  deriving instance GHC.Classes.Eq a_466 => GHC.Classes.Eq (OrderBys a_466)
  
  deriving instance GHC.Classes.Ord a_467 => GHC.Classes.Ord (OrderBys a_467)
  
  deriving instance GHC.Show.Show a_468 => GHC.Show.Show (OrderBys a_468)
  
  instance AST.Unmarshal.Unmarshal OrderBys
  
  instance Data.Foldable.Foldable OrderBys where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OrderBys where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OrderBys where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ParExpr a = ParExpr
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_469.
        AST.Traversable1.Class.Traversable1 a_469
      )
  
  instance AST.Unmarshal.SymbolMatching ParExpr where
    matchedSymbols _ = [128]
    showFailure _ node_470 =
      "expected "
        GHC.Base.<> ( "par_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_470 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_470) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_471 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_472 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_473 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_474 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_471
          c1_472 = TreeSitter.Node.nodeStartPoint node_470
        TreeSitter.Node.TSPoint
          r2_473
          c2_474 = TreeSitter.Node.nodeEndPoint node_470
  
  deriving instance GHC.Classes.Eq a_475 => GHC.Classes.Eq (ParExpr a_475)
  
  deriving instance GHC.Classes.Ord a_476 => GHC.Classes.Ord (ParExpr a_476)
  
  deriving instance GHC.Show.Show a_477 => GHC.Show.Show (ParExpr a_477)
  
  instance AST.Unmarshal.Unmarshal ParExpr
  
  instance Data.Foldable.Foldable ParExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ParExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ParExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PredicateAliasBody a = PredicateAliasBody
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Eq GHC.Generics.:+: PredicateExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_478.
        AST.Traversable1.Class.Traversable1 a_478
      )
  
  instance AST.Unmarshal.SymbolMatching PredicateAliasBody where
    matchedSymbols _ = [87]
    showFailure _ node_479 =
      "expected "
        GHC.Base.<> ( "predicateAliasBody"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_479 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_479) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_480 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_481 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_482 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_483 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_480
          c1_481 = TreeSitter.Node.nodeStartPoint node_479
        TreeSitter.Node.TSPoint
          r2_482
          c2_483 = TreeSitter.Node.nodeEndPoint node_479
  
  deriving instance GHC.Classes.Eq a_484 => GHC.Classes.Eq (PredicateAliasBody a_484)
  
  deriving instance GHC.Classes.Ord a_485 => GHC.Classes.Ord (PredicateAliasBody a_485)
  
  deriving instance GHC.Show.Show a_486 => GHC.Show.Show (PredicateAliasBody a_486)
  
  instance AST.Unmarshal.Unmarshal PredicateAliasBody
  
  instance Data.Foldable.Foldable PredicateAliasBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PredicateAliasBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PredicateAliasBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PredicateExpr a = PredicateExpr
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AritylessPredicateExpr GHC.Generics.:+: Integer GHC.Generics.:+: Slash) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_487.
        AST.Traversable1.Class.Traversable1 a_487
      )
  
  instance AST.Unmarshal.SymbolMatching PredicateExpr where
    matchedSymbols _ = [161]
    showFailure _ node_488 =
      "expected "
        GHC.Base.<> ( "predicateExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_488 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_488) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_489 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_490 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_491 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_492 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_489
          c1_490 = TreeSitter.Node.nodeStartPoint node_488
        TreeSitter.Node.TSPoint
          r2_491
          c2_492 = TreeSitter.Node.nodeEndPoint node_488
  
  deriving instance GHC.Classes.Eq a_493 => GHC.Classes.Eq (PredicateExpr a_493)
  
  deriving instance GHC.Classes.Ord a_494 => GHC.Classes.Ord (PredicateExpr a_494)
  
  deriving instance GHC.Show.Show a_495 => GHC.Show.Show (PredicateExpr a_495)
  
  instance AST.Unmarshal.Unmarshal PredicateExpr
  
  instance Data.Foldable.Foldable PredicateExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PredicateExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PredicateExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PredicateName a = PredicateName {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_496.
        AST.Traversable1.Class.Traversable1 a_496
      )
  
  instance AST.Unmarshal.SymbolMatching PredicateName where
    matchedSymbols _ = [159]
    showFailure _ node_497 =
      "expected "
        GHC.Base.<> ( "predicateName"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_497 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_497) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_498 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_499 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_500 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_501 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_498
          c1_499 = TreeSitter.Node.nodeStartPoint node_497
        TreeSitter.Node.TSPoint
          r2_500
          c2_501 = TreeSitter.Node.nodeEndPoint node_497
  
  deriving instance GHC.Classes.Eq a_502 => GHC.Classes.Eq (PredicateName a_502)
  
  deriving instance GHC.Classes.Ord a_503 => GHC.Classes.Ord (PredicateName a_503)
  
  deriving instance GHC.Show.Show a_504 => GHC.Show.Show (PredicateName a_504)
  
  instance AST.Unmarshal.Unmarshal PredicateName
  
  instance Data.Foldable.Foldable PredicateName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PredicateName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PredicateName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PrefixCast a = PrefixCast
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: TypeExpr GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_505.
        AST.Traversable1.Class.Traversable1 a_505
      )
  
  instance AST.Unmarshal.SymbolMatching PrefixCast where
    matchedSymbols _ = [104]
    showFailure _ node_506 =
      "expected "
        GHC.Base.<> ( "prefix_cast"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_506 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_506) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_507 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_508 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_509 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_510 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_507
          c1_508 = TreeSitter.Node.nodeStartPoint node_506
        TreeSitter.Node.TSPoint
          r2_509
          c2_510 = TreeSitter.Node.nodeEndPoint node_506
  
  deriving instance GHC.Classes.Eq a_511 => GHC.Classes.Eq (PrefixCast a_511)
  
  deriving instance GHC.Classes.Ord a_512 => GHC.Classes.Ord (PrefixCast a_512)
  
  deriving instance GHC.Show.Show a_513 => GHC.Show.Show (PrefixCast a_513)
  
  instance AST.Unmarshal.Unmarshal PrefixCast
  
  instance Data.Foldable.Foldable PrefixCast where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PrefixCast where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PrefixCast where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Ql a = Ql
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (ModuleMember a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_514.
        AST.Traversable1.Class.Traversable1 a_514
      )
  
  instance AST.Unmarshal.SymbolMatching Ql where
    matchedSymbols _ = [82]
    showFailure _ node_515 =
      "expected "
        GHC.Base.<> ( "ql"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_515 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_515) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_516 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_517 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_518 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_519 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_516
          c1_517 = TreeSitter.Node.nodeStartPoint node_515
        TreeSitter.Node.TSPoint
          r2_518
          c2_519 = TreeSitter.Node.nodeEndPoint node_515
  
  deriving instance GHC.Classes.Eq a_520 => GHC.Classes.Eq (Ql a_520)
  
  deriving instance GHC.Classes.Ord a_521 => GHC.Classes.Ord (Ql a_521)
  
  deriving instance GHC.Show.Show a_522 => GHC.Show.Show (Ql a_522)
  
  instance AST.Unmarshal.Unmarshal Ql
  
  instance Data.Foldable.Foldable Ql where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Ql where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Ql where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data QualModuleExpr a = QualModuleExpr
    { ann :: a,
      name :: (GHC.Base.NonEmpty (AST.Parse.Err (SimpleId a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_523.
        AST.Traversable1.Class.Traversable1 a_523
      )
  
  instance AST.Unmarshal.SymbolMatching QualModuleExpr where
    matchedSymbols _ = [150]
    showFailure _ node_524 =
      "expected "
        GHC.Base.<> ( "qualModuleExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_524 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_524) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_525 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_526 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_527 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_528 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_525
          c1_526 = TreeSitter.Node.nodeStartPoint node_524
        TreeSitter.Node.TSPoint
          r2_527
          c2_528 = TreeSitter.Node.nodeEndPoint node_524
  
  deriving instance GHC.Classes.Eq a_529 => GHC.Classes.Eq (QualModuleExpr a_529)
  
  deriving instance GHC.Classes.Ord a_530 => GHC.Classes.Ord (QualModuleExpr a_530)
  
  deriving instance GHC.Show.Show a_531 => GHC.Show.Show (QualModuleExpr a_531)
  
  instance AST.Unmarshal.Unmarshal QualModuleExpr
  
  instance Data.Foldable.Foldable QualModuleExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor QualModuleExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable QualModuleExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data QualifiedRhs a = QualifiedRhs
    { ann :: a,
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (PredicateName a))),
      extraChildren :: ([AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: Closure GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: TypeExpr GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Underscore GHC.Generics.:+: Variable) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_532.
        AST.Traversable1.Class.Traversable1 a_532
      )
  
  instance AST.Unmarshal.SymbolMatching QualifiedRhs where
    matchedSymbols _ = [120]
    showFailure _ node_533 =
      "expected "
        GHC.Base.<> ( "qualifiedRhs"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_533 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_533) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_534 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_535 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_536 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_537 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_534
          c1_535 = TreeSitter.Node.nodeStartPoint node_533
        TreeSitter.Node.TSPoint
          r2_536
          c2_537 = TreeSitter.Node.nodeEndPoint node_533
  
  deriving instance GHC.Classes.Eq a_538 => GHC.Classes.Eq (QualifiedRhs a_538)
  
  deriving instance GHC.Classes.Ord a_539 => GHC.Classes.Ord (QualifiedRhs a_539)
  
  deriving instance GHC.Show.Show a_540 => GHC.Show.Show (QualifiedRhs a_540)
  
  instance AST.Unmarshal.Unmarshal QualifiedRhs
  
  instance Data.Foldable.Foldable QualifiedRhs where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor QualifiedRhs where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable QualifiedRhs where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data QualifiedExpr a = QualifiedExpr
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: Literal GHC.Generics.:+: ParExpr GHC.Generics.:+: QualifiedRhs GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Range GHC.Generics.:+: SuperRef GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_541.
        AST.Traversable1.Class.Traversable1 a_541
      )
  
  instance AST.Unmarshal.SymbolMatching QualifiedExpr where
    matchedSymbols _ = [122]
    showFailure _ node_542 =
      "expected "
        GHC.Base.<> ( "qualified_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_542 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_542) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_543 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_544 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_545 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_546 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_543
          c1_544 = TreeSitter.Node.nodeStartPoint node_542
        TreeSitter.Node.TSPoint
          r2_545
          c2_546 = TreeSitter.Node.nodeEndPoint node_542
  
  deriving instance GHC.Classes.Eq a_547 => GHC.Classes.Eq (QualifiedExpr a_547)
  
  deriving instance GHC.Classes.Ord a_548 => GHC.Classes.Ord (QualifiedExpr a_548)
  
  deriving instance GHC.Show.Show a_549 => GHC.Show.Show (QualifiedExpr a_549)
  
  instance AST.Unmarshal.Unmarshal QualifiedExpr
  
  instance Data.Foldable.Foldable QualifiedExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor QualifiedExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable QualifiedExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Quantified a = Quantified
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Quantifier GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: VarDecl GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_550.
        AST.Traversable1.Class.Traversable1 a_550
      )
  
  instance AST.Unmarshal.SymbolMatching Quantified where
    matchedSymbols _ = [116]
    showFailure _ node_551 =
      "expected "
        GHC.Base.<> ( "quantified"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_551 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_551) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_552 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_553 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_554 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_555 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_552
          c1_553 = TreeSitter.Node.nodeStartPoint node_551
        TreeSitter.Node.TSPoint
          r2_554
          c2_555 = TreeSitter.Node.nodeEndPoint node_551
  
  deriving instance GHC.Classes.Eq a_556 => GHC.Classes.Eq (Quantified a_556)
  
  deriving instance GHC.Classes.Ord a_557 => GHC.Classes.Ord (Quantified a_557)
  
  deriving instance GHC.Show.Show a_558 => GHC.Show.Show (Quantified a_558)
  
  instance AST.Unmarshal.Unmarshal Quantified
  
  instance Data.Foldable.Foldable Quantified where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Quantified where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Quantified where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Quantifier a = Quantifier
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Exists GHC.Generics.:+: Forall GHC.Generics.:+: Forex) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_559.
        AST.Traversable1.Class.Traversable1 a_559
      )
  
  instance AST.Unmarshal.SymbolMatching Quantifier where
    matchedSymbols _ = [118]
    showFailure _ node_560 =
      "expected "
        GHC.Base.<> ( "quantifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_560 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_560) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_561 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_562 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_563 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_564 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_561
          c1_562 = TreeSitter.Node.nodeStartPoint node_560
        TreeSitter.Node.TSPoint
          r2_563
          c2_564 = TreeSitter.Node.nodeEndPoint node_560
  
  deriving instance GHC.Classes.Eq a_565 => GHC.Classes.Eq (Quantifier a_565)
  
  deriving instance GHC.Classes.Ord a_566 => GHC.Classes.Ord (Quantifier a_566)
  
  deriving instance GHC.Show.Show a_567 => GHC.Show.Show (Quantifier a_567)
  
  instance AST.Unmarshal.Unmarshal Quantifier
  
  instance Data.Foldable.Foldable Quantifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Quantifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Quantifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Range a = Range
    { ann :: a,
      upper :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a)),
      lower :: (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Variable) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_568.
        AST.Traversable1.Class.Traversable1 a_568
      )
  
  instance AST.Unmarshal.SymbolMatching Range where
    matchedSymbols _ = [127]
    showFailure _ node_569 =
      "expected "
        GHC.Base.<> ( "range"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_569 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_569) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_570 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_571 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_572 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_573 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_570
          c1_571 = TreeSitter.Node.nodeStartPoint node_569
        TreeSitter.Node.TSPoint
          r2_572
          c2_573 = TreeSitter.Node.nodeEndPoint node_569
  
  deriving instance GHC.Classes.Eq a_574 => GHC.Classes.Eq (Range a_574)
  
  deriving instance GHC.Classes.Ord a_575 => GHC.Classes.Ord (Range a_575)
  
  deriving instance GHC.Show.Show a_576 => GHC.Show.Show (Range a_576)
  
  instance AST.Unmarshal.Unmarshal Range
  
  instance Data.Foldable.Foldable Range where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Range where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Range where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ReturnType a = ReturnType
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Predicate GHC.Generics.:+: TypeExpr) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_577.
        AST.Traversable1.Class.Traversable1 a_577
      )
  
  instance AST.Unmarshal.SymbolMatching ReturnType where
    matchedSymbols _ = [157]
    showFailure _ node_578 =
      "expected "
        GHC.Base.<> ( "returnType"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_578 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_578) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_579 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_580 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_581 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_582 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_579
          c1_580 = TreeSitter.Node.nodeStartPoint node_578
        TreeSitter.Node.TSPoint
          r2_581
          c2_582 = TreeSitter.Node.nodeEndPoint node_578
  
  deriving instance GHC.Classes.Eq a_583 => GHC.Classes.Eq (ReturnType a_583)
  
  deriving instance GHC.Classes.Ord a_584 => GHC.Classes.Ord (ReturnType a_584)
  
  deriving instance GHC.Show.Show a_585 => GHC.Show.Show (ReturnType a_585)
  
  instance AST.Unmarshal.Unmarshal ReturnType
  
  instance Data.Foldable.Foldable ReturnType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ReturnType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ReturnType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Select a = Select
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: AsExprs GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: OrderBys GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: VarDecl GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_586.
        AST.Traversable1.Class.Traversable1 a_586
      )
  
  instance AST.Unmarshal.SymbolMatching Select where
    matchedSymbols _ = [93]
    showFailure _ node_587 =
      "expected "
        GHC.Base.<> ( "select"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_587 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_587) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_588 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_589 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_590 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_591 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_588
          c1_589 = TreeSitter.Node.nodeStartPoint node_587
        TreeSitter.Node.TSPoint
          r2_590
          c2_591 = TreeSitter.Node.nodeEndPoint node_587
  
  deriving instance GHC.Classes.Eq a_592 => GHC.Classes.Eq (Select a_592)
  
  deriving instance GHC.Classes.Ord a_593 => GHC.Classes.Ord (Select a_593)
  
  deriving instance GHC.Show.Show a_594 => GHC.Show.Show (Select a_594)
  
  instance AST.Unmarshal.Unmarshal Select
  
  instance Data.Foldable.Foldable Select where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Select where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Select where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SimpleId a = SimpleId {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_595.
        AST.Traversable1.Class.Traversable1 a_595
      )
  
  instance AST.Unmarshal.SymbolMatching SimpleId where
    matchedSymbols _ = [154]
    showFailure _ node_596 =
      "expected "
        GHC.Base.<> ( "simpleId"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_596 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_596) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_597 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_598 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_599 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_600 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_597
          c1_598 = TreeSitter.Node.nodeStartPoint node_596
        TreeSitter.Node.TSPoint
          r2_599
          c2_600 = TreeSitter.Node.nodeEndPoint node_596
  
  deriving instance GHC.Classes.Eq a_601 => GHC.Classes.Eq (SimpleId a_601)
  
  deriving instance GHC.Classes.Ord a_602 => GHC.Classes.Ord (SimpleId a_602)
  
  deriving instance GHC.Show.Show a_603 => GHC.Show.Show (SimpleId a_603)
  
  instance AST.Unmarshal.Unmarshal SimpleId
  
  instance Data.Foldable.Foldable SimpleId where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SimpleId where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SimpleId where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SpecialId a = SpecialId {ann :: a, extraChildren :: (AST.Parse.Err (None a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_604.
        AST.Traversable1.Class.Traversable1 a_604
      )
  
  instance AST.Unmarshal.SymbolMatching SpecialId where
    matchedSymbols _ = [117]
    showFailure _ node_605 =
      "expected "
        GHC.Base.<> ( "specialId"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_605 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_605) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_606 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_607 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_608 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_609 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_606
          c1_607 = TreeSitter.Node.nodeStartPoint node_605
        TreeSitter.Node.TSPoint
          r2_608
          c2_609 = TreeSitter.Node.nodeEndPoint node_605
  
  deriving instance GHC.Classes.Eq a_610 => GHC.Classes.Eq (SpecialId a_610)
  
  deriving instance GHC.Classes.Ord a_611 => GHC.Classes.Ord (SpecialId a_611)
  
  deriving instance GHC.Show.Show a_612 => GHC.Show.Show (SpecialId a_612)
  
  instance AST.Unmarshal.Unmarshal SpecialId
  
  instance Data.Foldable.Foldable SpecialId where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SpecialId where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SpecialId where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SpecialCall a = SpecialCall
    { ann :: a,
      extraChildren :: (AST.Parse.Err (SpecialId a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_613.
        AST.Traversable1.Class.Traversable1 a_613
      )
  
  instance AST.Unmarshal.SymbolMatching SpecialCall where
    matchedSymbols _ = [103]
    showFailure _ node_614 =
      "expected "
        GHC.Base.<> ( "special_call"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_614 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_614) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_615 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_616 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_617 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_618 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_615
          c1_616 = TreeSitter.Node.nodeStartPoint node_614
        TreeSitter.Node.TSPoint
          r2_617
          c2_618 = TreeSitter.Node.nodeEndPoint node_614
  
  deriving instance GHC.Classes.Eq a_619 => GHC.Classes.Eq (SpecialCall a_619)
  
  deriving instance GHC.Classes.Ord a_620 => GHC.Classes.Ord (SpecialCall a_620)
  
  deriving instance GHC.Show.Show a_621 => GHC.Show.Show (SpecialCall a_621)
  
  instance AST.Unmarshal.Unmarshal SpecialCall
  
  instance Data.Foldable.Foldable SpecialCall where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SpecialCall where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SpecialCall where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SuperRef a = SuperRef
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Super GHC.Generics.:+: TypeExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_622.
        AST.Traversable1.Class.Traversable1 a_622
      )
  
  instance AST.Unmarshal.SymbolMatching SuperRef where
    matchedSymbols _ = [123]
    showFailure _ node_623 =
      "expected "
        GHC.Base.<> ( "super_ref"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_623 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_623) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_624 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_625 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_626 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_627 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_624
          c1_625 = TreeSitter.Node.nodeStartPoint node_623
        TreeSitter.Node.TSPoint
          r2_626
          c2_627 = TreeSitter.Node.nodeEndPoint node_623
  
  deriving instance GHC.Classes.Eq a_628 => GHC.Classes.Eq (SuperRef a_628)
  
  deriving instance GHC.Classes.Ord a_629 => GHC.Classes.Ord (SuperRef a_629)
  
  deriving instance GHC.Show.Show a_630 => GHC.Show.Show (SuperRef a_630)
  
  instance AST.Unmarshal.Unmarshal SuperRef
  
  instance Data.Foldable.Foldable SuperRef where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SuperRef where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SuperRef where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeAliasBody a = TypeAliasBody
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Eq GHC.Generics.:+: TypeExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_631.
        AST.Traversable1.Class.Traversable1 a_631
      )
  
  instance AST.Unmarshal.SymbolMatching TypeAliasBody where
    matchedSymbols _ = [88]
    showFailure _ node_632 =
      "expected "
        GHC.Base.<> ( "typeAliasBody"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_632 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_632) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_633 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_634 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_635 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_636 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_633
          c1_634 = TreeSitter.Node.nodeStartPoint node_632
        TreeSitter.Node.TSPoint
          r2_635
          c2_636 = TreeSitter.Node.nodeEndPoint node_632
  
  deriving instance GHC.Classes.Eq a_637 => GHC.Classes.Eq (TypeAliasBody a_637)
  
  deriving instance GHC.Classes.Ord a_638 => GHC.Classes.Ord (TypeAliasBody a_638)
  
  deriving instance GHC.Show.Show a_639 => GHC.Show.Show (TypeAliasBody a_639)
  
  instance AST.Unmarshal.Unmarshal TypeAliasBody
  
  instance Data.Foldable.Foldable TypeAliasBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeAliasBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeAliasBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeExpr a = TypeExpr
    { ann :: a,
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (ClassName a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((ModuleExpr GHC.Generics.:+: TypeLiteral) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_640.
        AST.Traversable1.Class.Traversable1 a_640
      )
  
  instance AST.Unmarshal.SymbolMatching TypeExpr where
    matchedSymbols _ = [158]
    showFailure _ node_641 =
      "expected "
        GHC.Base.<> ( "typeExpr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_641 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_641) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_642 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_643 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_644 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_645 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_642
          c1_643 = TreeSitter.Node.nodeStartPoint node_641
        TreeSitter.Node.TSPoint
          r2_644
          c2_645 = TreeSitter.Node.nodeEndPoint node_641
  
  deriving instance GHC.Classes.Eq a_646 => GHC.Classes.Eq (TypeExpr a_646)
  
  deriving instance GHC.Classes.Ord a_647 => GHC.Classes.Ord (TypeExpr a_647)
  
  deriving instance GHC.Show.Show a_648 => GHC.Show.Show (TypeExpr a_648)
  
  instance AST.Unmarshal.Unmarshal TypeExpr
  
  instance Data.Foldable.Foldable TypeExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeLiteral a = TypeLiteral
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((Boolean GHC.Generics.:+: Date GHC.Generics.:+: Dbtype) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_649.
        AST.Traversable1.Class.Traversable1 a_649
      )
  
  instance AST.Unmarshal.SymbolMatching TypeLiteral where
    matchedSymbols _ = [153]
    showFailure _ node_650 =
      "expected "
        GHC.Base.<> ( "typeLiteral"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_650 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_650) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_651 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_652 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_653 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_654 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_651
          c1_652 = TreeSitter.Node.nodeStartPoint node_650
        TreeSitter.Node.TSPoint
          r2_653
          c2_654 = TreeSitter.Node.nodeEndPoint node_650
  
  deriving instance GHC.Classes.Eq a_655 => GHC.Classes.Eq (TypeLiteral a_655)
  
  deriving instance GHC.Classes.Ord a_656 => GHC.Classes.Ord (TypeLiteral a_656)
  
  deriving instance GHC.Show.Show a_657 => GHC.Show.Show (TypeLiteral a_657)
  
  instance AST.Unmarshal.Unmarshal TypeLiteral
  
  instance Data.Foldable.Foldable TypeLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnaryExpr a = UnaryExpr
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((AddExpr GHC.Generics.:+: Aggregate GHC.Generics.:+: ClasslessPredicateCall GHC.Generics.:+: CompTerm GHC.Generics.:+: Conjunction GHC.Generics.:+: Disjunction GHC.Generics.:+: IfTerm GHC.Generics.:+: Implication GHC.Generics.:+: InExpr GHC.Generics.:+: InstanceOf GHC.Generics.:+: Literal GHC.Generics.:+: MulExpr GHC.Generics.:+: Negation GHC.Generics.:+: ParExpr GHC.Generics.:+: PrefixCast GHC.Generics.:+: QualifiedExpr GHC.Generics.:+: Quantified GHC.Generics.:+: Range GHC.Generics.:+: SpecialCall GHC.Generics.:+: SuperRef GHC.Generics.:+: UnaryExpr GHC.Generics.:+: Unop GHC.Generics.:+: Variable) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_658.
        AST.Traversable1.Class.Traversable1 a_658
      )
  
  instance AST.Unmarshal.SymbolMatching UnaryExpr where
    matchedSymbols _ = [105]
    showFailure _ node_659 =
      "expected "
        GHC.Base.<> ( "unary_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_659 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_659) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_660 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_661 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_662 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_663 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_660
          c1_661 = TreeSitter.Node.nodeStartPoint node_659
        TreeSitter.Node.TSPoint
          r2_662
          c2_663 = TreeSitter.Node.nodeEndPoint node_659
  
  deriving instance GHC.Classes.Eq a_664 => GHC.Classes.Eq (UnaryExpr a_664)
  
  deriving instance GHC.Classes.Ord a_665 => GHC.Classes.Ord (UnaryExpr a_665)
  
  deriving instance GHC.Show.Show a_666 => GHC.Show.Show (UnaryExpr a_666)
  
  instance AST.Unmarshal.Unmarshal UnaryExpr
  
  instance Data.Foldable.Foldable UnaryExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnaryExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnaryExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Unop a = Unop
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Minus GHC.Generics.:+: Plus) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_667.
        AST.Traversable1.Class.Traversable1 a_667
      )
  
  instance AST.Unmarshal.SymbolMatching Unop where
    matchedSymbols _ = [135]
    showFailure _ node_668 =
      "expected "
        GHC.Base.<> ( "unop"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_668 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_668) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_669 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_670 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_671 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_672 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_669
          c1_670 = TreeSitter.Node.nodeStartPoint node_668
        TreeSitter.Node.TSPoint
          r2_671
          c2_672 = TreeSitter.Node.nodeEndPoint node_668
  
  deriving instance GHC.Classes.Eq a_673 => GHC.Classes.Eq (Unop a_673)
  
  deriving instance GHC.Classes.Ord a_674 => GHC.Classes.Ord (Unop a_674)
  
  deriving instance GHC.Show.Show a_675 => GHC.Show.Show (Unop a_675)
  
  instance AST.Unmarshal.Unmarshal Unop
  
  instance Data.Foldable.Foldable Unop where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Unop where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Unop where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VarDecl a = VarDecl
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((TypeExpr GHC.Generics.:+: VarName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_676.
        AST.Traversable1.Class.Traversable1 a_676
      )
  
  instance AST.Unmarshal.SymbolMatching VarDecl where
    matchedSymbols _ = [140]
    showFailure _ node_677 =
      "expected "
        GHC.Base.<> ( "varDecl"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_677 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_677) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_678 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_679 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_680 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_681 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_678
          c1_679 = TreeSitter.Node.nodeStartPoint node_677
        TreeSitter.Node.TSPoint
          r2_680
          c2_681 = TreeSitter.Node.nodeEndPoint node_677
  
  deriving instance GHC.Classes.Eq a_682 => GHC.Classes.Eq (VarDecl a_682)
  
  deriving instance GHC.Classes.Ord a_683 => GHC.Classes.Ord (VarDecl a_683)
  
  deriving instance GHC.Show.Show a_684 => GHC.Show.Show (VarDecl a_684)
  
  instance AST.Unmarshal.Unmarshal VarDecl
  
  instance Data.Foldable.Foldable VarDecl where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VarDecl where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VarDecl where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VarName a = VarName {ann :: a, extraChildren :: (AST.Parse.Err (SimpleId a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_685.
        AST.Traversable1.Class.Traversable1 a_685
      )
  
  instance AST.Unmarshal.SymbolMatching VarName where
    matchedSymbols _ = [162]
    showFailure _ node_686 =
      "expected "
        GHC.Base.<> ( "varName"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_686 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_686) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_687 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_688 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_689 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_690 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_687
          c1_688 = TreeSitter.Node.nodeStartPoint node_686
        TreeSitter.Node.TSPoint
          r2_689
          c2_690 = TreeSitter.Node.nodeEndPoint node_686
  
  deriving instance GHC.Classes.Eq a_691 => GHC.Classes.Eq (VarName a_691)
  
  deriving instance GHC.Classes.Ord a_692 => GHC.Classes.Ord (VarName a_692)
  
  deriving instance GHC.Show.Show a_693 => GHC.Show.Show (VarName a_693)
  
  instance AST.Unmarshal.Unmarshal VarName
  
  instance Data.Foldable.Foldable VarName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VarName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VarName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Variable a = Variable
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Result GHC.Generics.:+: This GHC.Generics.:+: VarName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_694.
        AST.Traversable1.Class.Traversable1 a_694
      )
  
  instance AST.Unmarshal.SymbolMatching Variable where
    matchedSymbols _ = [133]
    showFailure _ node_695 =
      "expected "
        GHC.Base.<> ( "variable"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_695 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_695) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_696 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_697 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_698 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_699 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_696
          c1_697 = TreeSitter.Node.nodeStartPoint node_695
        TreeSitter.Node.TSPoint
          r2_698
          c2_699 = TreeSitter.Node.nodeEndPoint node_695
  
  deriving instance GHC.Classes.Eq a_700 => GHC.Classes.Eq (Variable a_700)
  
  deriving instance GHC.Classes.Ord a_701 => GHC.Classes.Ord (Variable a_701)
  
  deriving instance GHC.Show.Show a_702 => GHC.Show.Show (Variable a_702)
  
  instance AST.Unmarshal.Unmarshal Variable
  
  instance Data.Foldable.Foldable Variable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Variable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Variable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousLParen = AST.Token.Token "(" 6
  
  type AnonymousRParen = AST.Token.Token ")" 8
  
  type AnonymousComma = AST.Token.Token "," 7
  
  type AnonymousDot = AST.Token.Token "." 19
  
  type AnonymousDotDot = AST.Token.Token ".." 22
  
  type AnonymousColonColon = AST.Token.Token "::" 26
  
  type AnonymousSemicolon = AST.Token.Token ";" 5
  
  type AnonymousLBracket = AST.Token.Token "[" 20
  
  type AnonymousRBracket = AST.Token.Token "]" 21
  
  type AnonymousAnd = AST.Token.Token "and" 16
  
  data Any a = Any {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_703.
        AST.Traversable1.Class.Traversable1 a_703
      )
  
  instance AST.Unmarshal.SymbolMatching Any where
    matchedSymbols _ = [37]
    showFailure _ node_704 =
      "expected "
        GHC.Base.<> ( "any"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_704 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_704) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_705 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_706 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_707 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_708 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_705
          c1_706 = TreeSitter.Node.nodeStartPoint node_704
        TreeSitter.Node.TSPoint
          r2_707
          c2_708 = TreeSitter.Node.nodeEndPoint node_704
  
  deriving instance GHC.Classes.Eq a_709 => GHC.Classes.Eq (Any a_709)
  
  deriving instance GHC.Classes.Ord a_710 => GHC.Classes.Ord (Any a_710)
  
  deriving instance GHC.Show.Show a_711 => GHC.Show.Show (Any a_711)
  
  instance AST.Unmarshal.Unmarshal Any
  
  instance Data.Foldable.Foldable Any where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Any where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Any where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data As a = As {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_712.
        AST.Traversable1.Class.Traversable1 a_712
      )
  
  instance AST.Unmarshal.SymbolMatching As where
    matchedSymbols _ = [38]
    showFailure _ node_713 =
      "expected "
        GHC.Base.<> ( "as"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_713 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_713) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_714 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_715 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_716 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_717 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_714
          c1_715 = TreeSitter.Node.nodeStartPoint node_713
        TreeSitter.Node.TSPoint
          r2_716
          c2_717 = TreeSitter.Node.nodeEndPoint node_713
  
  deriving instance GHC.Classes.Eq a_718 => GHC.Classes.Eq (As a_718)
  
  deriving instance GHC.Classes.Ord a_719 => GHC.Classes.Ord (As a_719)
  
  deriving instance GHC.Show.Show a_720 => GHC.Show.Show (As a_720)
  
  instance AST.Unmarshal.Unmarshal As
  
  instance Data.Foldable.Foldable As where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor As where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable As where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Asc a = Asc {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_721.
        AST.Traversable1.Class.Traversable1 a_721
      )
  
  instance AST.Unmarshal.SymbolMatching Asc where
    matchedSymbols _ = [39]
    showFailure _ node_722 =
      "expected "
        GHC.Base.<> ( "asc"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_722 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_722) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_723 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_724 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_725 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_726 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_723
          c1_724 = TreeSitter.Node.nodeStartPoint node_722
        TreeSitter.Node.TSPoint
          r2_725
          c2_726 = TreeSitter.Node.nodeEndPoint node_722
  
  deriving instance GHC.Classes.Eq a_727 => GHC.Classes.Eq (Asc a_727)
  
  deriving instance GHC.Classes.Ord a_728 => GHC.Classes.Ord (Asc a_728)
  
  deriving instance GHC.Show.Show a_729 => GHC.Show.Show (Asc a_729)
  
  instance AST.Unmarshal.Unmarshal Asc
  
  instance Data.Foldable.Foldable Asc where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Asc where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Asc where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Avg a = Avg {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_730.
        AST.Traversable1.Class.Traversable1 a_730
      )
  
  instance AST.Unmarshal.SymbolMatching Avg where
    matchedSymbols _ = [40]
    showFailure _ node_731 =
      "expected "
        GHC.Base.<> ( "avg"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_731 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_731) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_732 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_733 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_734 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_735 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_732
          c1_733 = TreeSitter.Node.nodeStartPoint node_731
        TreeSitter.Node.TSPoint
          r2_734
          c2_735 = TreeSitter.Node.nodeEndPoint node_731
  
  deriving instance GHC.Classes.Eq a_736 => GHC.Classes.Eq (Avg a_736)
  
  deriving instance GHC.Classes.Ord a_737 => GHC.Classes.Ord (Avg a_737)
  
  deriving instance GHC.Show.Show a_738 => GHC.Show.Show (Avg a_738)
  
  instance AST.Unmarshal.Unmarshal Avg
  
  instance Data.Foldable.Foldable Avg where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Avg where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Avg where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Boolean a = Boolean {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_739.
        AST.Traversable1.Class.Traversable1 a_739
      )
  
  instance AST.Unmarshal.SymbolMatching Boolean where
    matchedSymbols _ = [41]
    showFailure _ node_740 =
      "expected "
        GHC.Base.<> ( "boolean"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_740 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_740) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_741 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_742 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_743 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_744 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_741
          c1_742 = TreeSitter.Node.nodeStartPoint node_740
        TreeSitter.Node.TSPoint
          r2_743
          c2_744 = TreeSitter.Node.nodeEndPoint node_740
  
  deriving instance GHC.Classes.Eq a_745 => GHC.Classes.Eq (Boolean a_745)
  
  deriving instance GHC.Classes.Ord a_746 => GHC.Classes.Ord (Boolean a_746)
  
  deriving instance GHC.Show.Show a_747 => GHC.Show.Show (Boolean a_747)
  
  instance AST.Unmarshal.Unmarshal Boolean
  
  instance Data.Foldable.Foldable Boolean where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Boolean where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Boolean where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBy = AST.Token.Token "by" 24
  
  data Class a = Class {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_748.
        AST.Traversable1.Class.Traversable1 a_748
      )
  
  instance AST.Unmarshal.SymbolMatching Class where
    matchedSymbols _ = [42]
    showFailure _ node_749 =
      "expected "
        GHC.Base.<> ( "class"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_749 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_749) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_750 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_751 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_752 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_753 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_750
          c1_751 = TreeSitter.Node.nodeStartPoint node_749
        TreeSitter.Node.TSPoint
          r2_752
          c2_753 = TreeSitter.Node.nodeEndPoint node_749
  
  deriving instance GHC.Classes.Eq a_754 => GHC.Classes.Eq (Class a_754)
  
  deriving instance GHC.Classes.Ord a_755 => GHC.Classes.Ord (Class a_755)
  
  deriving instance GHC.Show.Show a_756 => GHC.Show.Show (Class a_756)
  
  instance AST.Unmarshal.Unmarshal Class
  
  instance Data.Foldable.Foldable Class where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Class where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Class where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Concat a = Concat {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_757.
        AST.Traversable1.Class.Traversable1 a_757
      )
  
  instance AST.Unmarshal.SymbolMatching Concat where
    matchedSymbols _ = [65]
    showFailure _ node_758 =
      "expected "
        GHC.Base.<> ( "concat"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_758 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_758) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_759 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_760 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_761 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_762 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_759
          c1_760 = TreeSitter.Node.nodeStartPoint node_758
        TreeSitter.Node.TSPoint
          r2_761
          c2_762 = TreeSitter.Node.nodeEndPoint node_758
  
  deriving instance GHC.Classes.Eq a_763 => GHC.Classes.Eq (Concat a_763)
  
  deriving instance GHC.Classes.Ord a_764 => GHC.Classes.Ord (Concat a_764)
  
  deriving instance GHC.Show.Show a_765 => GHC.Show.Show (Concat a_765)
  
  instance AST.Unmarshal.Unmarshal Concat
  
  instance Data.Foldable.Foldable Concat where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Concat where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Concat where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Count a = Count {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_766.
        AST.Traversable1.Class.Traversable1 a_766
      )
  
  instance AST.Unmarshal.SymbolMatching Count where
    matchedSymbols _ = [44]
    showFailure _ node_767 =
      "expected "
        GHC.Base.<> ( "count"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_767 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_767) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_768 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_769 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_770 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_771 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_768
          c1_769 = TreeSitter.Node.nodeStartPoint node_767
        TreeSitter.Node.TSPoint
          r2_770
          c2_771 = TreeSitter.Node.nodeEndPoint node_767
  
  deriving instance GHC.Classes.Eq a_772 => GHC.Classes.Eq (Count a_772)
  
  deriving instance GHC.Classes.Ord a_773 => GHC.Classes.Ord (Count a_773)
  
  deriving instance GHC.Show.Show a_774 => GHC.Show.Show (Count a_774)
  
  instance AST.Unmarshal.Unmarshal Count
  
  instance Data.Foldable.Foldable Count where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Count where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Count where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Date a = Date {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_775.
        AST.Traversable1.Class.Traversable1 a_775
      )
  
  instance AST.Unmarshal.SymbolMatching Date where
    matchedSymbols _ = [45]
    showFailure _ node_776 =
      "expected "
        GHC.Base.<> ( "date"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_776 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_776) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_777 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_778 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_779 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_780 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_777
          c1_778 = TreeSitter.Node.nodeStartPoint node_776
        TreeSitter.Node.TSPoint
          r2_779
          c2_780 = TreeSitter.Node.nodeEndPoint node_776
  
  deriving instance GHC.Classes.Eq a_781 => GHC.Classes.Eq (Date a_781)
  
  deriving instance GHC.Classes.Ord a_782 => GHC.Classes.Ord (Date a_782)
  
  deriving instance GHC.Show.Show a_783 => GHC.Show.Show (Date a_783)
  
  instance AST.Unmarshal.Unmarshal Date
  
  instance Data.Foldable.Foldable Date where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Date where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Date where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Desc a = Desc {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_784.
        AST.Traversable1.Class.Traversable1 a_784
      )
  
  instance AST.Unmarshal.SymbolMatching Desc where
    matchedSymbols _ = [46]
    showFailure _ node_785 =
      "expected "
        GHC.Base.<> ( "desc"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_785 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_785) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_786 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_787 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_788 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_789 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_786
          c1_787 = TreeSitter.Node.nodeStartPoint node_785
        TreeSitter.Node.TSPoint
          r2_788
          c2_789 = TreeSitter.Node.nodeEndPoint node_785
  
  deriving instance GHC.Classes.Eq a_790 => GHC.Classes.Eq (Desc a_790)
  
  deriving instance GHC.Classes.Ord a_791 => GHC.Classes.Ord (Desc a_791)
  
  deriving instance GHC.Show.Show a_792 => GHC.Show.Show (Desc a_792)
  
  instance AST.Unmarshal.Unmarshal Desc
  
  instance Data.Foldable.Foldable Desc where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Desc where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Desc where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousElse = AST.Token.Token "else" 15
  
  data Eq a = Eq {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_793.
        AST.Traversable1.Class.Traversable1 a_793
      )
  
  instance AST.Unmarshal.SymbolMatching Eq where
    matchedSymbols _ = [72]
    showFailure _ node_794 =
      "expected "
        GHC.Base.<> ( "eq"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_794 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_794) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_795 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_796 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_797 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_798 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_795
          c1_796 = TreeSitter.Node.nodeStartPoint node_794
        TreeSitter.Node.TSPoint
          r2_797
          c2_798 = TreeSitter.Node.nodeEndPoint node_794
  
  deriving instance GHC.Classes.Eq a_799 => GHC.Classes.Eq (Eq a_799)
  
  deriving instance GHC.Classes.Ord a_800 => GHC.Classes.Ord (Eq a_800)
  
  deriving instance GHC.Show.Show a_801 => GHC.Show.Show (Eq a_801)
  
  instance AST.Unmarshal.Unmarshal Eq
  
  instance Data.Foldable.Foldable Eq where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Eq where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Eq where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Exists a = Exists {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_802.
        AST.Traversable1.Class.Traversable1 a_802
      )
  
  instance AST.Unmarshal.SymbolMatching Exists where
    matchedSymbols _ = [47]
    showFailure _ node_803 =
      "expected "
        GHC.Base.<> ( "exists"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_803 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_803) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_804 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_805 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_806 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_807 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_804
          c1_805 = TreeSitter.Node.nodeStartPoint node_803
        TreeSitter.Node.TSPoint
          r2_806
          c2_807 = TreeSitter.Node.nodeEndPoint node_803
  
  deriving instance GHC.Classes.Eq a_808 => GHC.Classes.Eq (Exists a_808)
  
  deriving instance GHC.Classes.Ord a_809 => GHC.Classes.Ord (Exists a_809)
  
  deriving instance GHC.Show.Show a_810 => GHC.Show.Show (Exists a_810)
  
  instance AST.Unmarshal.Unmarshal Exists
  
  instance Data.Foldable.Foldable Exists where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Exists where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Exists where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Extends a = Extends {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_811.
        AST.Traversable1.Class.Traversable1 a_811
      )
  
  instance AST.Unmarshal.SymbolMatching Extends where
    matchedSymbols _ = [48]
    showFailure _ node_812 =
      "expected "
        GHC.Base.<> ( "extends"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_812 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_812) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_813 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_814 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_815 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_816 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_813
          c1_814 = TreeSitter.Node.nodeStartPoint node_812
        TreeSitter.Node.TSPoint
          r2_815
          c2_816 = TreeSitter.Node.nodeEndPoint node_812
  
  deriving instance GHC.Classes.Eq a_817 => GHC.Classes.Eq (Extends a_817)
  
  deriving instance GHC.Classes.Ord a_818 => GHC.Classes.Ord (Extends a_818)
  
  deriving instance GHC.Show.Show a_819 => GHC.Show.Show (Extends a_819)
  
  instance AST.Unmarshal.Unmarshal Extends
  
  instance Data.Foldable.Foldable Extends where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Extends where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Extends where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data False a = False {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_820.
        AST.Traversable1.Class.Traversable1 a_820
      )
  
  instance AST.Unmarshal.SymbolMatching False where
    matchedSymbols _ = [49]
    showFailure _ node_821 =
      "expected "
        GHC.Base.<> ( "false"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_821 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_821) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_822 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_823 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_824 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_825 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_822
          c1_823 = TreeSitter.Node.nodeStartPoint node_821
        TreeSitter.Node.TSPoint
          r2_824
          c2_825 = TreeSitter.Node.nodeEndPoint node_821
  
  deriving instance GHC.Classes.Eq a_826 => GHC.Classes.Eq (False a_826)
  
  deriving instance GHC.Classes.Ord a_827 => GHC.Classes.Ord (False a_827)
  
  deriving instance GHC.Show.Show a_828 => GHC.Show.Show (False a_828)
  
  instance AST.Unmarshal.Unmarshal False
  
  instance Data.Foldable.Foldable False where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor False where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable False where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousFloat = AST.Token.Token "float" 27
  
  data Float a = Float {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_829.
        AST.Traversable1.Class.Traversable1 a_829
      )
  
  instance AST.Unmarshal.SymbolMatching Float where
    matchedSymbols _ = [33]
    showFailure _ node_830 =
      "expected "
        GHC.Base.<> ( "float"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_830 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_830) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_831 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_832 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_833 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_834 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_831
          c1_832 = TreeSitter.Node.nodeStartPoint node_830
        TreeSitter.Node.TSPoint
          r2_833
          c2_834 = TreeSitter.Node.nodeEndPoint node_830
  
  deriving instance GHC.Classes.Eq a_835 => GHC.Classes.Eq (Float a_835)
  
  deriving instance GHC.Classes.Ord a_836 => GHC.Classes.Ord (Float a_836)
  
  deriving instance GHC.Show.Show a_837 => GHC.Show.Show (Float a_837)
  
  instance AST.Unmarshal.Unmarshal Float
  
  instance Data.Foldable.Foldable Float where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Float where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Float where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Forall a = Forall {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_838.
        AST.Traversable1.Class.Traversable1 a_838
      )
  
  instance AST.Unmarshal.SymbolMatching Forall where
    matchedSymbols _ = [50]
    showFailure _ node_839 =
      "expected "
        GHC.Base.<> ( "forall"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_839 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_839) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_840 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_841 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_842 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_843 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_840
          c1_841 = TreeSitter.Node.nodeStartPoint node_839
        TreeSitter.Node.TSPoint
          r2_842
          c2_843 = TreeSitter.Node.nodeEndPoint node_839
  
  deriving instance GHC.Classes.Eq a_844 => GHC.Classes.Eq (Forall a_844)
  
  deriving instance GHC.Classes.Ord a_845 => GHC.Classes.Ord (Forall a_845)
  
  deriving instance GHC.Show.Show a_846 => GHC.Show.Show (Forall a_846)
  
  instance AST.Unmarshal.Unmarshal Forall
  
  instance Data.Foldable.Foldable Forall where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Forall where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Forall where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Forex a = Forex {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_847.
        AST.Traversable1.Class.Traversable1 a_847
      )
  
  instance AST.Unmarshal.SymbolMatching Forex where
    matchedSymbols _ = [51]
    showFailure _ node_848 =
      "expected "
        GHC.Base.<> ( "forex"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_848 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_848) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_849 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_850 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_851 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_852 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_849
          c1_850 = TreeSitter.Node.nodeStartPoint node_848
        TreeSitter.Node.TSPoint
          r2_851
          c2_852 = TreeSitter.Node.nodeEndPoint node_848
  
  deriving instance GHC.Classes.Eq a_853 => GHC.Classes.Eq (Forex a_853)
  
  deriving instance GHC.Classes.Ord a_854 => GHC.Classes.Ord (Forex a_854)
  
  deriving instance GHC.Show.Show a_855 => GHC.Show.Show (Forex a_855)
  
  instance AST.Unmarshal.Unmarshal Forex
  
  instance Data.Foldable.Foldable Forex where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Forex where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Forex where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousFrom = AST.Token.Token "from" 10
  
  data Ge a = Ge {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_856.
        AST.Traversable1.Class.Traversable1 a_856
      )
  
  instance AST.Unmarshal.SymbolMatching Ge where
    matchedSymbols _ = [74]
    showFailure _ node_857 =
      "expected "
        GHC.Base.<> ( "ge"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_857 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_857) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_858 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_859 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_860 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_861 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_858
          c1_859 = TreeSitter.Node.nodeStartPoint node_857
        TreeSitter.Node.TSPoint
          r2_860
          c2_861 = TreeSitter.Node.nodeEndPoint node_857
  
  deriving instance GHC.Classes.Eq a_862 => GHC.Classes.Eq (Ge a_862)
  
  deriving instance GHC.Classes.Ord a_863 => GHC.Classes.Ord (Ge a_863)
  
  deriving instance GHC.Show.Show a_864 => GHC.Show.Show (Ge a_864)
  
  instance AST.Unmarshal.Unmarshal Ge
  
  instance Data.Foldable.Foldable Ge where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Ge where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Ge where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Gt a = Gt {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_865.
        AST.Traversable1.Class.Traversable1 a_865
      )
  
  instance AST.Unmarshal.SymbolMatching Gt where
    matchedSymbols _ = [73]
    showFailure _ node_866 =
      "expected "
        GHC.Base.<> ( "gt"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_866 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_866) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_867 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_868 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_869 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_870 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_867
          c1_868 = TreeSitter.Node.nodeStartPoint node_866
        TreeSitter.Node.TSPoint
          r2_869
          c2_870 = TreeSitter.Node.nodeEndPoint node_866
  
  deriving instance GHC.Classes.Eq a_871 => GHC.Classes.Eq (Gt a_871)
  
  deriving instance GHC.Classes.Ord a_872 => GHC.Classes.Ord (Gt a_872)
  
  deriving instance GHC.Show.Show a_873 => GHC.Show.Show (Gt a_873)
  
  instance AST.Unmarshal.Unmarshal Gt
  
  instance Data.Foldable.Foldable Gt where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Gt where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Gt where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousIf = AST.Token.Token "if" 13
  
  type AnonymousImplies = AST.Token.Token "implies" 17
  
  data Import a = Import {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_874.
        AST.Traversable1.Class.Traversable1 a_874
      )
  
  instance AST.Unmarshal.SymbolMatching Import where
    matchedSymbols _ = [52]
    showFailure _ node_875 =
      "expected "
        GHC.Base.<> ( "import"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_875 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_875) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_876 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_877 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_878 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_879 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_876
          c1_877 = TreeSitter.Node.nodeStartPoint node_875
        TreeSitter.Node.TSPoint
          r2_878
          c2_879 = TreeSitter.Node.nodeEndPoint node_875
  
  deriving instance GHC.Classes.Eq a_880 => GHC.Classes.Eq (Import a_880)
  
  deriving instance GHC.Classes.Ord a_881 => GHC.Classes.Ord (Import a_881)
  
  deriving instance GHC.Show.Show a_882 => GHC.Show.Show (Import a_882)
  
  instance AST.Unmarshal.Unmarshal Import
  
  instance Data.Foldable.Foldable Import where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Import where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Import where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data In a = In {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_883.
        AST.Traversable1.Class.Traversable1 a_883
      )
  
  instance AST.Unmarshal.SymbolMatching In where
    matchedSymbols _ = [53]
    showFailure _ node_884 =
      "expected "
        GHC.Base.<> ( "in"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_884 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_884) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_885 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_886 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_887 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_888 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_885
          c1_886 = TreeSitter.Node.nodeStartPoint node_884
        TreeSitter.Node.TSPoint
          r2_887
          c2_888 = TreeSitter.Node.nodeEndPoint node_884
  
  deriving instance GHC.Classes.Eq a_889 => GHC.Classes.Eq (In a_889)
  
  deriving instance GHC.Classes.Ord a_890 => GHC.Classes.Ord (In a_890)
  
  deriving instance GHC.Show.Show a_891 => GHC.Show.Show (In a_891)
  
  instance AST.Unmarshal.Unmarshal In
  
  instance Data.Foldable.Foldable In where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor In where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable In where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Instanceof a = Instanceof {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_892.
        AST.Traversable1.Class.Traversable1 a_892
      )
  
  instance AST.Unmarshal.SymbolMatching Instanceof where
    matchedSymbols _ = [54]
    showFailure _ node_893 =
      "expected "
        GHC.Base.<> ( "instanceof"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_893 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_893) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_894 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_895 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_896 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_897 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_894
          c1_895 = TreeSitter.Node.nodeStartPoint node_893
        TreeSitter.Node.TSPoint
          r2_896
          c2_897 = TreeSitter.Node.nodeEndPoint node_893
  
  deriving instance GHC.Classes.Eq a_898 => GHC.Classes.Eq (Instanceof a_898)
  
  deriving instance GHC.Classes.Ord a_899 => GHC.Classes.Ord (Instanceof a_899)
  
  deriving instance GHC.Show.Show a_900 => GHC.Show.Show (Instanceof a_900)
  
  instance AST.Unmarshal.Unmarshal Instanceof
  
  instance Data.Foldable.Foldable Instanceof where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Instanceof where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Instanceof where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousInt = AST.Token.Token "int" 28
  
  data Integer a = Integer {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_901.
        AST.Traversable1.Class.Traversable1 a_901
      )
  
  instance AST.Unmarshal.SymbolMatching Integer where
    matchedSymbols _ = [32]
    showFailure _ node_902 =
      "expected "
        GHC.Base.<> ( "integer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_902 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_902) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_903 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_904 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_905 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_906 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_903
          c1_904 = TreeSitter.Node.nodeStartPoint node_902
        TreeSitter.Node.TSPoint
          r2_905
          c2_906 = TreeSitter.Node.nodeEndPoint node_902
  
  deriving instance GHC.Classes.Eq a_907 => GHC.Classes.Eq (Integer a_907)
  
  deriving instance GHC.Classes.Ord a_908 => GHC.Classes.Ord (Integer a_908)
  
  deriving instance GHC.Show.Show a_909 => GHC.Show.Show (Integer a_909)
  
  instance AST.Unmarshal.Unmarshal Integer
  
  instance Data.Foldable.Foldable Integer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Integer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Integer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Le a = Le {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_910.
        AST.Traversable1.Class.Traversable1 a_910
      )
  
  instance AST.Unmarshal.SymbolMatching Le where
    matchedSymbols _ = [71]
    showFailure _ node_911 =
      "expected "
        GHC.Base.<> ( "le"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_911 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_911) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_912 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_913 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_914 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_915 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_912
          c1_913 = TreeSitter.Node.nodeStartPoint node_911
        TreeSitter.Node.TSPoint
          r2_914
          c2_915 = TreeSitter.Node.nodeEndPoint node_911
  
  deriving instance GHC.Classes.Eq a_916 => GHC.Classes.Eq (Le a_916)
  
  deriving instance GHC.Classes.Ord a_917 => GHC.Classes.Ord (Le a_917)
  
  deriving instance GHC.Show.Show a_918 => GHC.Show.Show (Le a_918)
  
  instance AST.Unmarshal.Unmarshal Le
  
  instance Data.Foldable.Foldable Le where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Le where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Le where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Lt a = Lt {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_919.
        AST.Traversable1.Class.Traversable1 a_919
      )
  
  instance AST.Unmarshal.SymbolMatching Lt where
    matchedSymbols _ = [70]
    showFailure _ node_920 =
      "expected "
        GHC.Base.<> ( "lt"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_920 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_920) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_921 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_922 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_923 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_924 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_921
          c1_922 = TreeSitter.Node.nodeStartPoint node_920
        TreeSitter.Node.TSPoint
          r2_923
          c2_924 = TreeSitter.Node.nodeEndPoint node_920
  
  deriving instance GHC.Classes.Eq a_925 => GHC.Classes.Eq (Lt a_925)
  
  deriving instance GHC.Classes.Ord a_926 => GHC.Classes.Ord (Lt a_926)
  
  deriving instance GHC.Show.Show a_927 => GHC.Show.Show (Lt a_927)
  
  instance AST.Unmarshal.Unmarshal Lt
  
  instance Data.Foldable.Foldable Lt where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Lt where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Lt where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Max a = Max {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_928.
        AST.Traversable1.Class.Traversable1 a_928
      )
  
  instance AST.Unmarshal.SymbolMatching Max where
    matchedSymbols _ = [55]
    showFailure _ node_929 =
      "expected "
        GHC.Base.<> ( "max"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_929 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_929) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_930 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_931 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_932 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_933 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_930
          c1_931 = TreeSitter.Node.nodeStartPoint node_929
        TreeSitter.Node.TSPoint
          r2_932
          c2_933 = TreeSitter.Node.nodeEndPoint node_929
  
  deriving instance GHC.Classes.Eq a_934 => GHC.Classes.Eq (Max a_934)
  
  deriving instance GHC.Classes.Ord a_935 => GHC.Classes.Ord (Max a_935)
  
  deriving instance GHC.Show.Show a_936 => GHC.Show.Show (Max a_936)
  
  instance AST.Unmarshal.Unmarshal Max
  
  instance Data.Foldable.Foldable Max where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Max where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Max where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Min a = Min {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_937.
        AST.Traversable1.Class.Traversable1 a_937
      )
  
  instance AST.Unmarshal.SymbolMatching Min where
    matchedSymbols _ = [56]
    showFailure _ node_938 =
      "expected "
        GHC.Base.<> ( "min"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_938 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_938) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_939 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_940 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_941 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_942 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_939
          c1_940 = TreeSitter.Node.nodeStartPoint node_938
        TreeSitter.Node.TSPoint
          r2_941
          c2_942 = TreeSitter.Node.nodeEndPoint node_938
  
  deriving instance GHC.Classes.Eq a_943 => GHC.Classes.Eq (Min a_943)
  
  deriving instance GHC.Classes.Ord a_944 => GHC.Classes.Ord (Min a_944)
  
  deriving instance GHC.Show.Show a_945 => GHC.Show.Show (Min a_945)
  
  instance AST.Unmarshal.Unmarshal Min
  
  instance Data.Foldable.Foldable Min where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Min where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Min where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Minus a = Minus {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_946.
        AST.Traversable1.Class.Traversable1 a_946
      )
  
  instance AST.Unmarshal.SymbolMatching Minus where
    matchedSymbols _ = [76]
    showFailure _ node_947 =
      "expected "
        GHC.Base.<> ( "minus"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_947 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_947) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_948 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_949 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_950 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_951 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_948
          c1_949 = TreeSitter.Node.nodeStartPoint node_947
        TreeSitter.Node.TSPoint
          r2_950
          c2_951 = TreeSitter.Node.nodeEndPoint node_947
  
  deriving instance GHC.Classes.Eq a_952 => GHC.Classes.Eq (Minus a_952)
  
  deriving instance GHC.Classes.Ord a_953 => GHC.Classes.Ord (Minus a_953)
  
  deriving instance GHC.Show.Show a_954 => GHC.Show.Show (Minus a_954)
  
  instance AST.Unmarshal.Unmarshal Minus
  
  instance Data.Foldable.Foldable Minus where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Minus where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Minus where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Mod a = Mod {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_955.
        AST.Traversable1.Class.Traversable1 a_955
      )
  
  instance AST.Unmarshal.SymbolMatching Mod where
    matchedSymbols _ = [80]
    showFailure _ node_956 =
      "expected "
        GHC.Base.<> ( "mod"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_956 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_956) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_957 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_958 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_959 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_960 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_957
          c1_958 = TreeSitter.Node.nodeStartPoint node_956
        TreeSitter.Node.TSPoint
          r2_959
          c2_960 = TreeSitter.Node.nodeEndPoint node_956
  
  deriving instance GHC.Classes.Eq a_961 => GHC.Classes.Eq (Mod a_961)
  
  deriving instance GHC.Classes.Ord a_962 => GHC.Classes.Ord (Mod a_962)
  
  deriving instance GHC.Show.Show a_963 => GHC.Show.Show (Mod a_963)
  
  instance AST.Unmarshal.Unmarshal Mod
  
  instance Data.Foldable.Foldable Mod where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Mod where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Mod where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousModule = AST.Token.Token "module" 2
  
  data Ne a = Ne {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_964.
        AST.Traversable1.Class.Traversable1 a_964
      )
  
  instance AST.Unmarshal.SymbolMatching Ne where
    matchedSymbols _ = [77]
    showFailure _ node_965 =
      "expected "
        GHC.Base.<> ( "ne"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_965 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_965) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_966 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_967 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_968 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_969 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_966
          c1_967 = TreeSitter.Node.nodeStartPoint node_965
        TreeSitter.Node.TSPoint
          r2_968
          c2_969 = TreeSitter.Node.nodeEndPoint node_965
  
  deriving instance GHC.Classes.Eq a_970 => GHC.Classes.Eq (Ne a_970)
  
  deriving instance GHC.Classes.Ord a_971 => GHC.Classes.Ord (Ne a_971)
  
  deriving instance GHC.Show.Show a_972 => GHC.Show.Show (Ne a_972)
  
  instance AST.Unmarshal.Unmarshal Ne
  
  instance Data.Foldable.Foldable Ne where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Ne where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Ne where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Newtype a = Newtype {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_973.
        AST.Traversable1.Class.Traversable1 a_973
      )
  
  instance AST.Unmarshal.SymbolMatching Newtype where
    matchedSymbols _ = [43]
    showFailure _ node_974 =
      "expected "
        GHC.Base.<> ( "newtype"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_974 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_974) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_975 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_976 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_977 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_978 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_975
          c1_976 = TreeSitter.Node.nodeStartPoint node_974
        TreeSitter.Node.TSPoint
          r2_977
          c2_978 = TreeSitter.Node.nodeEndPoint node_974
  
  deriving instance GHC.Classes.Eq a_979 => GHC.Classes.Eq (Newtype a_979)
  
  deriving instance GHC.Classes.Ord a_980 => GHC.Classes.Ord (Newtype a_980)
  
  deriving instance GHC.Show.Show a_981 => GHC.Show.Show (Newtype a_981)
  
  instance AST.Unmarshal.Unmarshal Newtype
  
  instance Data.Foldable.Foldable Newtype where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Newtype where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Newtype where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data None a = None {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_982.
        AST.Traversable1.Class.Traversable1 a_982
      )
  
  instance AST.Unmarshal.SymbolMatching None where
    matchedSymbols _ = [58]
    showFailure _ node_983 =
      "expected "
        GHC.Base.<> ( "none"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_983 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_983) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_984 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_985 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_986 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_987 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_984
          c1_985 = TreeSitter.Node.nodeStartPoint node_983
        TreeSitter.Node.TSPoint
          r2_986
          c2_987 = TreeSitter.Node.nodeEndPoint node_983
  
  deriving instance GHC.Classes.Eq a_988 => GHC.Classes.Eq (None a_988)
  
  deriving instance GHC.Classes.Ord a_989 => GHC.Classes.Ord (None a_989)
  
  deriving instance GHC.Show.Show a_990 => GHC.Show.Show (None a_990)
  
  instance AST.Unmarshal.Unmarshal None
  
  instance Data.Foldable.Foldable None where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor None where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable None where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Not a = Not {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_991.
        AST.Traversable1.Class.Traversable1 a_991
      )
  
  instance AST.Unmarshal.SymbolMatching Not where
    matchedSymbols _ = [57]
    showFailure _ node_992 =
      "expected "
        GHC.Base.<> ( "not"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_992 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_992) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_993 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_994 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_995 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_996 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_993
          c1_994 = TreeSitter.Node.nodeStartPoint node_992
        TreeSitter.Node.TSPoint
          r2_995
          c2_996 = TreeSitter.Node.nodeEndPoint node_992
  
  deriving instance GHC.Classes.Eq a_997 => GHC.Classes.Eq (Not a_997)
  
  deriving instance GHC.Classes.Ord a_998 => GHC.Classes.Ord (Not a_998)
  
  deriving instance GHC.Show.Show a_999 => GHC.Show.Show (Not a_999)
  
  instance AST.Unmarshal.Unmarshal Not
  
  instance Data.Foldable.Foldable Not where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Not where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Not where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousOr = AST.Token.Token "or" 9
  
  type AnonymousOrder = AST.Token.Token "order" 23
  
  data Plus a = Plus {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1000.
        AST.Traversable1.Class.Traversable1 a_1000
      )
  
  instance AST.Unmarshal.SymbolMatching Plus where
    matchedSymbols _ = [81]
    showFailure _ node_1001 =
      "expected "
        GHC.Base.<> ( "plus"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1001 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1001) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1002 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1003 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1004 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1005 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1002
          c1_1003 = TreeSitter.Node.nodeStartPoint node_1001
        TreeSitter.Node.TSPoint
          r2_1004
          c2_1005 = TreeSitter.Node.nodeEndPoint node_1001
  
  deriving instance GHC.Classes.Eq a_1006 => GHC.Classes.Eq (Plus a_1006)
  
  deriving instance GHC.Classes.Ord a_1007 => GHC.Classes.Ord (Plus a_1007)
  
  deriving instance GHC.Show.Show a_1008 => GHC.Show.Show (Plus a_1008)
  
  instance AST.Unmarshal.Unmarshal Plus
  
  instance Data.Foldable.Foldable Plus where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Plus where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Plus where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Predicate a = Predicate {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1009.
        AST.Traversable1.Class.Traversable1 a_1009
      )
  
  instance AST.Unmarshal.SymbolMatching Predicate where
    matchedSymbols _ = [59]
    showFailure _ node_1010 =
      "expected "
        GHC.Base.<> ( "predicate"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1010 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1010) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1011 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1012 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1013 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1014 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1011
          c1_1012 = TreeSitter.Node.nodeStartPoint node_1010
        TreeSitter.Node.TSPoint
          r2_1013
          c2_1014 = TreeSitter.Node.nodeEndPoint node_1010
  
  deriving instance GHC.Classes.Eq a_1015 => GHC.Classes.Eq (Predicate a_1015)
  
  deriving instance GHC.Classes.Ord a_1016 => GHC.Classes.Ord (Predicate a_1016)
  
  deriving instance GHC.Show.Show a_1017 => GHC.Show.Show (Predicate a_1017)
  
  instance AST.Unmarshal.Unmarshal Predicate
  
  instance Data.Foldable.Foldable Predicate where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Predicate where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Predicate where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Qldoc a = Qldoc {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1018.
        AST.Traversable1.Class.Traversable1 a_1018
      )
  
  instance AST.Unmarshal.SymbolMatching Qldoc where
    matchedSymbols _ = [25]
    showFailure _ node_1019 =
      "expected "
        GHC.Base.<> ( "qldoc"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1019 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1019) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1020 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1021 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1022 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1023 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1020
          c1_1021 = TreeSitter.Node.nodeStartPoint node_1019
        TreeSitter.Node.TSPoint
          r2_1022
          c2_1023 = TreeSitter.Node.nodeEndPoint node_1019
  
  deriving instance GHC.Classes.Eq a_1024 => GHC.Classes.Eq (Qldoc a_1024)
  
  deriving instance GHC.Classes.Ord a_1025 => GHC.Classes.Ord (Qldoc a_1025)
  
  deriving instance GHC.Show.Show a_1026 => GHC.Show.Show (Qldoc a_1026)
  
  instance AST.Unmarshal.Unmarshal Qldoc
  
  instance Data.Foldable.Foldable Qldoc where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Qldoc where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Qldoc where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Rank a = Rank {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1027.
        AST.Traversable1.Class.Traversable1 a_1027
      )
  
  instance AST.Unmarshal.SymbolMatching Rank where
    matchedSymbols _ = [60]
    showFailure _ node_1028 =
      "expected "
        GHC.Base.<> ( "rank"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1028 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1028) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1029 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1030 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1031 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1032 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1029
          c1_1030 = TreeSitter.Node.nodeStartPoint node_1028
        TreeSitter.Node.TSPoint
          r2_1031
          c2_1032 = TreeSitter.Node.nodeEndPoint node_1028
  
  deriving instance GHC.Classes.Eq a_1033 => GHC.Classes.Eq (Rank a_1033)
  
  deriving instance GHC.Classes.Ord a_1034 => GHC.Classes.Ord (Rank a_1034)
  
  deriving instance GHC.Show.Show a_1035 => GHC.Show.Show (Rank a_1035)
  
  instance AST.Unmarshal.Unmarshal Rank
  
  instance Data.Foldable.Foldable Rank where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Rank where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Rank where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Result a = Result {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1036.
        AST.Traversable1.Class.Traversable1 a_1036
      )
  
  instance AST.Unmarshal.SymbolMatching Result where
    matchedSymbols _ = [61]
    showFailure _ node_1037 =
      "expected "
        GHC.Base.<> ( "result"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1037 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1037) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1038 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1039 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1040 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1041 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1038
          c1_1039 = TreeSitter.Node.nodeStartPoint node_1037
        TreeSitter.Node.TSPoint
          r2_1040
          c2_1041 = TreeSitter.Node.nodeEndPoint node_1037
  
  deriving instance GHC.Classes.Eq a_1042 => GHC.Classes.Eq (Result a_1042)
  
  deriving instance GHC.Classes.Ord a_1043 => GHC.Classes.Ord (Result a_1043)
  
  deriving instance GHC.Show.Show a_1044 => GHC.Show.Show (Result a_1044)
  
  instance AST.Unmarshal.Unmarshal Result
  
  instance Data.Foldable.Foldable Result where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Result where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Result where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousSelect = AST.Token.Token "select" 12
  
  data Slash a = Slash {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1045.
        AST.Traversable1.Class.Traversable1 a_1045
      )
  
  instance AST.Unmarshal.SymbolMatching Slash where
    matchedSymbols _ = [78]
    showFailure _ node_1046 =
      "expected "
        GHC.Base.<> ( "slash"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1046 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1046) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1047 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1048 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1049 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1050 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1047
          c1_1048 = TreeSitter.Node.nodeStartPoint node_1046
        TreeSitter.Node.TSPoint
          r2_1049
          c2_1050 = TreeSitter.Node.nodeEndPoint node_1046
  
  deriving instance GHC.Classes.Eq a_1051 => GHC.Classes.Eq (Slash a_1051)
  
  deriving instance GHC.Classes.Ord a_1052 => GHC.Classes.Ord (Slash a_1052)
  
  deriving instance GHC.Show.Show a_1053 => GHC.Show.Show (Slash a_1053)
  
  instance AST.Unmarshal.Unmarshal Slash
  
  instance Data.Foldable.Foldable Slash where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Slash where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Slash where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Star a = Star {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1054.
        AST.Traversable1.Class.Traversable1 a_1054
      )
  
  instance AST.Unmarshal.SymbolMatching Star where
    matchedSymbols _ = [79]
    showFailure _ node_1055 =
      "expected "
        GHC.Base.<> ( "star"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1055 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1055) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1056 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1057 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1058 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1059 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1056
          c1_1057 = TreeSitter.Node.nodeStartPoint node_1055
        TreeSitter.Node.TSPoint
          r2_1058
          c2_1059 = TreeSitter.Node.nodeEndPoint node_1055
  
  deriving instance GHC.Classes.Eq a_1060 => GHC.Classes.Eq (Star a_1060)
  
  deriving instance GHC.Classes.Ord a_1061 => GHC.Classes.Ord (Star a_1061)
  
  deriving instance GHC.Show.Show a_1062 => GHC.Show.Show (Star a_1062)
  
  instance AST.Unmarshal.Unmarshal Star
  
  instance Data.Foldable.Foldable Star where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Star where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Star where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Strictconcat a = Strictconcat {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1063.
        AST.Traversable1.Class.Traversable1 a_1063
      )
  
  instance AST.Unmarshal.SymbolMatching Strictconcat where
    matchedSymbols _ = [64]
    showFailure _ node_1064 =
      "expected "
        GHC.Base.<> ( "strictconcat"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1064 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1064) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1065 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1066 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1067 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1068 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1065
          c1_1066 = TreeSitter.Node.nodeStartPoint node_1064
        TreeSitter.Node.TSPoint
          r2_1067
          c2_1068 = TreeSitter.Node.nodeEndPoint node_1064
  
  deriving instance GHC.Classes.Eq a_1069 => GHC.Classes.Eq (Strictconcat a_1069)
  
  deriving instance GHC.Classes.Ord a_1070 => GHC.Classes.Ord (Strictconcat a_1070)
  
  deriving instance GHC.Show.Show a_1071 => GHC.Show.Show (Strictconcat a_1071)
  
  instance AST.Unmarshal.Unmarshal Strictconcat
  
  instance Data.Foldable.Foldable Strictconcat where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Strictconcat where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Strictconcat where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Strictcount a = Strictcount {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1072.
        AST.Traversable1.Class.Traversable1 a_1072
      )
  
  instance AST.Unmarshal.SymbolMatching Strictcount where
    matchedSymbols _ = [62]
    showFailure _ node_1073 =
      "expected "
        GHC.Base.<> ( "strictcount"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1073 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1073) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1074 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1075 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1076 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1077 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1074
          c1_1075 = TreeSitter.Node.nodeStartPoint node_1073
        TreeSitter.Node.TSPoint
          r2_1076
          c2_1077 = TreeSitter.Node.nodeEndPoint node_1073
  
  deriving instance GHC.Classes.Eq a_1078 => GHC.Classes.Eq (Strictcount a_1078)
  
  deriving instance GHC.Classes.Ord a_1079 => GHC.Classes.Ord (Strictcount a_1079)
  
  deriving instance GHC.Show.Show a_1080 => GHC.Show.Show (Strictcount a_1080)
  
  instance AST.Unmarshal.Unmarshal Strictcount
  
  instance Data.Foldable.Foldable Strictcount where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Strictcount where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Strictcount where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Strictsum a = Strictsum {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1081.
        AST.Traversable1.Class.Traversable1 a_1081
      )
  
  instance AST.Unmarshal.SymbolMatching Strictsum where
    matchedSymbols _ = [63]
    showFailure _ node_1082 =
      "expected "
        GHC.Base.<> ( "strictsum"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1082 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1082) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1083 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1084 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1085 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1086 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1083
          c1_1084 = TreeSitter.Node.nodeStartPoint node_1082
        TreeSitter.Node.TSPoint
          r2_1085
          c2_1086 = TreeSitter.Node.nodeEndPoint node_1082
  
  deriving instance GHC.Classes.Eq a_1087 => GHC.Classes.Eq (Strictsum a_1087)
  
  deriving instance GHC.Classes.Ord a_1088 => GHC.Classes.Ord (Strictsum a_1088)
  
  deriving instance GHC.Show.Show a_1089 => GHC.Show.Show (Strictsum a_1089)
  
  instance AST.Unmarshal.Unmarshal Strictsum
  
  instance Data.Foldable.Foldable Strictsum where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Strictsum where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Strictsum where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data String a = String {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1090.
        AST.Traversable1.Class.Traversable1 a_1090
      )
  
  instance AST.Unmarshal.SymbolMatching String where
    matchedSymbols _ = [34]
    showFailure _ node_1091 =
      "expected "
        GHC.Base.<> ( "string"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1091 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1091) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1092 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1093 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1094 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1095 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1092
          c1_1093 = TreeSitter.Node.nodeStartPoint node_1091
        TreeSitter.Node.TSPoint
          r2_1094
          c2_1095 = TreeSitter.Node.nodeEndPoint node_1091
  
  deriving instance GHC.Classes.Eq a_1096 => GHC.Classes.Eq (String a_1096)
  
  deriving instance GHC.Classes.Ord a_1097 => GHC.Classes.Ord (String a_1097)
  
  deriving instance GHC.Show.Show a_1098 => GHC.Show.Show (String a_1098)
  
  instance AST.Unmarshal.Unmarshal String
  
  instance Data.Foldable.Foldable String where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor String where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable String where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousString = AST.Token.Token "string" 29
  
  data Sum a = Sum {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1099.
        AST.Traversable1.Class.Traversable1 a_1099
      )
  
  instance AST.Unmarshal.SymbolMatching Sum where
    matchedSymbols _ = [66]
    showFailure _ node_1100 =
      "expected "
        GHC.Base.<> ( "sum"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1100 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1100) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1101 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1102 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1103 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1104 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1101
          c1_1102 = TreeSitter.Node.nodeStartPoint node_1100
        TreeSitter.Node.TSPoint
          r2_1103
          c2_1104 = TreeSitter.Node.nodeEndPoint node_1100
  
  deriving instance GHC.Classes.Eq a_1105 => GHC.Classes.Eq (Sum a_1105)
  
  deriving instance GHC.Classes.Ord a_1106 => GHC.Classes.Ord (Sum a_1106)
  
  deriving instance GHC.Show.Show a_1107 => GHC.Show.Show (Sum a_1107)
  
  instance AST.Unmarshal.Unmarshal Sum
  
  instance Data.Foldable.Foldable Sum where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Sum where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Sum where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Super a = Super {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1108.
        AST.Traversable1.Class.Traversable1 a_1108
      )
  
  instance AST.Unmarshal.SymbolMatching Super where
    matchedSymbols _ = [67]
    showFailure _ node_1109 =
      "expected "
        GHC.Base.<> ( "super"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1109 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1109) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1110 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1111 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1112 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1113 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1110
          c1_1111 = TreeSitter.Node.nodeStartPoint node_1109
        TreeSitter.Node.TSPoint
          r2_1112
          c2_1113 = TreeSitter.Node.nodeEndPoint node_1109
  
  deriving instance GHC.Classes.Eq a_1114 => GHC.Classes.Eq (Super a_1114)
  
  deriving instance GHC.Classes.Ord a_1115 => GHC.Classes.Ord (Super a_1115)
  
  deriving instance GHC.Show.Show a_1116 => GHC.Show.Show (Super a_1116)
  
  instance AST.Unmarshal.Unmarshal Super
  
  instance Data.Foldable.Foldable Super where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Super where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Super where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousThen = AST.Token.Token "then" 14
  
  data This a = This {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1117.
        AST.Traversable1.Class.Traversable1 a_1117
      )
  
  instance AST.Unmarshal.SymbolMatching This where
    matchedSymbols _ = [68]
    showFailure _ node_1118 =
      "expected "
        GHC.Base.<> ( "this"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1118 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1118) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1119 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1120 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1121 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1122 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1119
          c1_1120 = TreeSitter.Node.nodeStartPoint node_1118
        TreeSitter.Node.TSPoint
          r2_1121
          c2_1122 = TreeSitter.Node.nodeEndPoint node_1118
  
  deriving instance GHC.Classes.Eq a_1123 => GHC.Classes.Eq (This a_1123)
  
  deriving instance GHC.Classes.Ord a_1124 => GHC.Classes.Ord (This a_1124)
  
  deriving instance GHC.Show.Show a_1125 => GHC.Show.Show (This a_1125)
  
  instance AST.Unmarshal.Unmarshal This
  
  instance Data.Foldable.Foldable This where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor This where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable This where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data True a = True {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1126.
        AST.Traversable1.Class.Traversable1 a_1126
      )
  
  instance AST.Unmarshal.SymbolMatching True where
    matchedSymbols _ = [69]
    showFailure _ node_1127 =
      "expected "
        GHC.Base.<> ( "true"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1127 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1127) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1128 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1129 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1130 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1131 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1128
          c1_1129 = TreeSitter.Node.nodeStartPoint node_1127
        TreeSitter.Node.TSPoint
          r2_1130
          c2_1131 = TreeSitter.Node.nodeEndPoint node_1127
  
  deriving instance GHC.Classes.Eq a_1132 => GHC.Classes.Eq (True a_1132)
  
  deriving instance GHC.Classes.Ord a_1133 => GHC.Classes.Ord (True a_1133)
  
  deriving instance GHC.Show.Show a_1134 => GHC.Show.Show (True a_1134)
  
  instance AST.Unmarshal.Unmarshal True
  
  instance Data.Foldable.Foldable True where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor True where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable True where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Underscore a = Underscore {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1135.
        AST.Traversable1.Class.Traversable1 a_1135
      )
  
  instance AST.Unmarshal.SymbolMatching Underscore where
    matchedSymbols _ = [75]
    showFailure _ node_1136 =
      "expected "
        GHC.Base.<> ( "underscore"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1136 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1136) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1137 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1138 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1139 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1140 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1137
          c1_1138 = TreeSitter.Node.nodeStartPoint node_1136
        TreeSitter.Node.TSPoint
          r2_1139
          c2_1140 = TreeSitter.Node.nodeEndPoint node_1136
  
  deriving instance GHC.Classes.Eq a_1141 => GHC.Classes.Eq (Underscore a_1141)
  
  deriving instance GHC.Classes.Ord a_1142 => GHC.Classes.Ord (Underscore a_1142)
  
  deriving instance GHC.Show.Show a_1143 => GHC.Show.Show (Underscore a_1143)
  
  instance AST.Unmarshal.Unmarshal Underscore
  
  instance Data.Foldable.Foldable Underscore where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Underscore where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Underscore where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousWhere = AST.Token.Token "where" 11
  
  type AnonymousLBrace = AST.Token.Token "{" 3
  
  type AnonymousPipe = AST.Token.Token "|" 18
  
  type AnonymousRBrace = AST.Token.Token "}" 4
  