-- 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
