content: -- Language definition for Java, 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.Java.AST (module Language.Java.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 TreeSitter.Java (getTestCorpusDir)
  import qualified TreeSitter.Node
  import qualified Prelude as GHC.Classes
  
  debugSymbolNames :: [GHC.Base.String]
  debugSymbolNames = debugSymbolNames_0
  
  debugSymbolNames_0 :: [GHC.Base.String]
  debugSymbolNames_0 =
    [ "end",
      "identifier",
      "decimal_integer_literal",
      "hex_integer_literal",
      "octal_integer_literal",
      "binary_integer_literal",
      "decimal_floating_point_literal",
      "hex_floating_point_literal",
      "true",
      "false",
      "character_literal",
      "string_literal",
      "null_literal",
      "_(",
      "_&",
      "_)",
      "_=",
      "_+=",
      "_-=",
      "_*=",
      "_/=",
      "_&=",
      "_|=",
      "_^=",
      "_%=",
      "_<<=",
      "_>>=",
      "_>>>=",
      "_>",
      "_<",
      "_==",
      "_>=",
      "_<=",
      "_!=",
      "_&&",
      "_||",
      "_+",
      "_-",
      "_*",
      "_/",
      "_|",
      "_^",
      "_%",
      "_<<",
      "_>>",
      "_>>>",
      "_instanceof",
      "_->",
      "_,",
      "_?",
      "_:",
      "_!",
      "_~",
      "_++",
      "_--",
      "_new",
      "_[",
      "_]",
      "_.",
      "_class",
      "_::",
      "_extends",
      "_;",
      "_{",
      "_}",
      "_assert",
      "_switch",
      "_case",
      "_default",
      "_do",
      "_while",
      "_break",
      "_continue",
      "_return",
      "_synchronized",
      "_throw",
      "_try",
      "_catch",
      "_finally",
      "_if",
      "_else",
      "_for",
      "_@",
      "_open",
      "_module",
      "_requires",
      "_exports",
      "_to",
      "_opens",
      "_uses",
      "_provides",
      "_with",
      "_transitive",
      "_static",
      "_package",
      "_import",
      "_enum",
      "_public",
      "_protected",
      "_private",
      "_abstract",
      "_final",
      "_strictfp",
      "_native",
      "_transient",
      "_volatile",
      "_implements",
      "_@interface",
      "_interface",
      "_byte",
      "_short",
      "_int",
      "_long",
      "_char",
      "_float",
      "_double",
      "boolean_type",
      "void_type",
      "_...",
      "_throws",
      "this",
      "super",
      "comment",
      "program",
      "_literal",
      "_expression",
      "cast_expression",
      "assignment_expression",
      "binary_expression",
      "instanceof_expression",
      "lambda_expression",
      "inferred_parameters",
      "ternary_expression",
      "unary_expression",
      "update_expression",
      "_primary",
      "array_creation_expression",
      "dimensions_expr",
      "parenthesized_expression",
      "class_literal",
      "object_creation_expression",
      "_unqualified_object_creation_expression",
      "field_access",
      "array_access",
      "method_invocation",
      "argument_list",
      "method_reference",
      "type_arguments",
      "wildcard",
      "_wildcard_bounds",
      "dimensions",
      "_statement",
      "block",
      "expression_statement",
      "labeled_statement",
      "assert_statement",
      "switch_statement",
      "switch_block",
      "switch_label",
      "do_statement",
      "break_statement",
      "continue_statement",
      "return_statement",
      "synchronized_statement",
      "throw_statement",
      "try_statement",
      "catch_clause",
      "catch_formal_parameter",
      "catch_type",
      "finally_clause",
      "try_with_resources_statement",
      "resource_specification",
      "resource",
      "if_statement",
      "while_statement",
      "for_statement",
      "for_init",
      "enhanced_for_statement",
      "_annotation",
      "marker_annotation",
      "annotation",
      "annotation_argument_list",
      "element_value_pair",
      "_element_value",
      "element_value_array_initializer",
      "_declaration",
      "module_declaration",
      "module_directive",
      "requires_modifier",
      "module_name",
      "package_declaration",
      "import_declaration",
      "asterisk",
      "enum_declaration",
      "enum_body",
      "enum_body_declarations",
      "enum_constant",
      "class_declaration",
      "modifiers",
      "type_parameters",
      "type_parameter",
      "type_bound",
      "superclass",
      "super_interfaces",
      "interface_type_list",
      "class_body",
      "static_initializer",
      "constructor_declaration",
      "_constructor_declarator",
      "constructor_body",
      "explicit_constructor_invocation",
      "scoped_identifier",
      "field_declaration",
      "annotation_type_declaration",
      "annotation_type_body",
      "annotation_type_element_declaration",
      "_default_value",
      "interface_declaration",
      "extends_interfaces",
      "interface_body",
      "constant_declaration",
      "_variable_declarator_list",
      "variable_declarator",
      "_variable_declarator_id",
      "array_initializer",
      "_type",
      "_unannotated_type",
      "annotated_type",
      "scoped_type_identifier",
      "generic_type",
      "array_type",
      "integral_type",
      "floating_point_type",
      "_method_header",
      "_method_declarator",
      "formal_parameters",
      "formal_parameter",
      "receiver_parameter",
      "spread_parameter",
      "throws",
      "local_variable_declaration_statement",
      "local_variable_declaration",
      "method_declaration",
      "_program_repeat1",
      "_cast_expression_repeat1",
      "_inferred_parameters_repeat1",
      "_array_creation_expression_repeat1",
      "_dimensions_expr_repeat1",
      "_class_literal_repeat1",
      "_argument_list_repeat1",
      "_type_arguments_repeat1",
      "_dimensions_repeat1",
      "_switch_block_repeat1",
      "_try_statement_repeat1",
      "_catch_type_repeat1",
      "_resource_specification_repeat1",
      "_annotation_argument_list_repeat1",
      "_element_value_array_initializer_repeat1",
      "_module_declaration_repeat1",
      "_module_directive_repeat1",
      "_module_directive_repeat2",
      "_module_directive_repeat3",
      "_import_declaration_repeat1",
      "_enum_body_repeat1",
      "_enum_body_declarations_repeat1",
      "_modifiers_repeat1",
      "_type_parameters_repeat1",
      "_type_bound_repeat1",
      "_interface_type_list_repeat1",
      "_annotation_type_body_repeat1",
      "_interface_body_repeat1",
      "__variable_declarator_list_repeat1",
      "_array_initializer_repeat1",
      "_formal_parameters_repeat1",
      "type_identifier"
    ]
  
  newtype Declaration a = Declaration {getDeclaration :: ((AnnotationTypeDeclaration GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: EnumDeclaration GHC.Generics.:+: ImportDeclaration GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: ModuleDeclaration GHC.Generics.:+: PackageDeclaration) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1.
        AST.Traversable1.Class.Traversable1 a_1
      )
  
  instance GHC.Records.HasField "ann" (Declaration a_2) a_2 where
    getField = AST.Unmarshal.gann GHC.Base.. getDeclaration
  
  deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (Declaration a_3)
  
  deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (Declaration a_4)
  
  deriving instance GHC.Show.Show a_5 => GHC.Show.Show (Declaration a_5)
  
  instance AST.Unmarshal.Unmarshal Declaration
  
  instance Data.Foldable.Foldable Declaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Declaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Declaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Expression a = Expression {getExpression :: ((Primary GHC.Generics.:+: AssignmentExpression GHC.Generics.:+: BinaryExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: Identifier GHC.Generics.:+: InstanceofExpression GHC.Generics.:+: LambdaExpression GHC.Generics.:+: ScopedIdentifier GHC.Generics.:+: TernaryExpression GHC.Generics.:+: UnaryExpression GHC.Generics.:+: UpdateExpression) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_6.
        AST.Traversable1.Class.Traversable1 a_6
      )
  
  instance GHC.Records.HasField "ann" (Expression a_7) a_7 where
    getField = AST.Unmarshal.gann GHC.Base.. getExpression
  
  deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (Expression a_8)
  
  deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (Expression a_9)
  
  deriving instance GHC.Show.Show a_10 => GHC.Show.Show (Expression a_10)
  
  instance AST.Unmarshal.Unmarshal Expression
  
  instance Data.Foldable.Foldable Expression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Expression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Expression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Literal a = Literal {getLiteral :: ((BinaryIntegerLiteral GHC.Generics.:+: CharacterLiteral GHC.Generics.:+: DecimalFloatingPointLiteral GHC.Generics.:+: DecimalIntegerLiteral GHC.Generics.:+: False GHC.Generics.:+: HexFloatingPointLiteral GHC.Generics.:+: HexIntegerLiteral GHC.Generics.:+: NullLiteral GHC.Generics.:+: OctalIntegerLiteral GHC.Generics.:+: StringLiteral GHC.Generics.:+: True) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_11.
        AST.Traversable1.Class.Traversable1 a_11
      )
  
  instance GHC.Records.HasField "ann" (Literal a_12) a_12 where
    getField = AST.Unmarshal.gann GHC.Base.. getLiteral
  
  deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (Literal a_13)
  
  deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (Literal a_14)
  
  deriving instance GHC.Show.Show a_15 => GHC.Show.Show (Literal a_15)
  
  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
  
  newtype Primary a = Primary {getPrimary :: ((Literal GHC.Generics.:+: ArrayAccess GHC.Generics.:+: ArrayCreationExpression GHC.Generics.:+: ClassLiteral GHC.Generics.:+: FieldAccess GHC.Generics.:+: MethodInvocation GHC.Generics.:+: MethodReference GHC.Generics.:+: ObjectCreationExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: This) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_16.
        AST.Traversable1.Class.Traversable1 a_16
      )
  
  instance GHC.Records.HasField "ann" (Primary a_17) a_17 where
    getField = AST.Unmarshal.gann GHC.Base.. getPrimary
  
  deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (Primary a_18)
  
  deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (Primary a_19)
  
  deriving instance GHC.Show.Show a_20 => GHC.Show.Show (Primary a_20)
  
  instance AST.Unmarshal.Unmarshal Primary
  
  instance Data.Foldable.Foldable Primary where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Primary where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Primary where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype SimpleType a = SimpleType {getSimpleType :: ((BooleanType GHC.Generics.:+: FloatingPointType GHC.Generics.:+: GenericType GHC.Generics.:+: IntegralType GHC.Generics.:+: ScopedTypeIdentifier GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: VoidType) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_21.
        AST.Traversable1.Class.Traversable1 a_21
      )
  
  instance GHC.Records.HasField "ann" (SimpleType a_22) a_22 where
    getField = AST.Unmarshal.gann GHC.Base.. getSimpleType
  
  deriving instance GHC.Classes.Eq a_23 => GHC.Classes.Eq (SimpleType a_23)
  
  deriving instance GHC.Classes.Ord a_24 => GHC.Classes.Ord (SimpleType a_24)
  
  deriving instance GHC.Show.Show a_25 => GHC.Show.Show (SimpleType a_25)
  
  instance AST.Unmarshal.Unmarshal SimpleType
  
  instance Data.Foldable.Foldable SimpleType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SimpleType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SimpleType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Statement a = Statement {getStatement :: ((AnonymousSemicolon GHC.Generics.:+: Declaration GHC.Generics.:+: AssertStatement GHC.Generics.:+: Block GHC.Generics.:+: BreakStatement GHC.Generics.:+: ContinueStatement GHC.Generics.:+: DoStatement GHC.Generics.:+: EnhancedForStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: ForStatement GHC.Generics.:+: IfStatement GHC.Generics.:+: LabeledStatement GHC.Generics.:+: LocalVariableDeclarationStatement GHC.Generics.:+: ReturnStatement GHC.Generics.:+: SwitchStatement GHC.Generics.:+: SynchronizedStatement GHC.Generics.:+: ThrowStatement GHC.Generics.:+: TryStatement GHC.Generics.:+: TryWithResourcesStatement GHC.Generics.:+: WhileStatement) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_26.
        AST.Traversable1.Class.Traversable1 a_26
      )
  
  instance GHC.Records.HasField "ann" (Statement a_27) a_27 where
    getField = AST.Unmarshal.gann GHC.Base.. getStatement
  
  deriving instance GHC.Classes.Eq a_28 => GHC.Classes.Eq (Statement a_28)
  
  deriving instance GHC.Classes.Ord a_29 => GHC.Classes.Ord (Statement a_29)
  
  deriving instance GHC.Show.Show a_30 => GHC.Show.Show (Statement a_30)
  
  instance AST.Unmarshal.Unmarshal Statement
  
  instance Data.Foldable.Foldable Statement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Statement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Statement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Type a = Type {getType :: ((UnannotatedType GHC.Generics.:+: AnnotatedType) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_31.
        AST.Traversable1.Class.Traversable1 a_31
      )
  
  instance GHC.Records.HasField "ann" (Type a_32) a_32 where
    getField = AST.Unmarshal.gann GHC.Base.. getType
  
  deriving instance GHC.Classes.Eq a_33 => GHC.Classes.Eq (Type a_33)
  
  deriving instance GHC.Classes.Ord a_34 => GHC.Classes.Ord (Type a_34)
  
  deriving instance GHC.Show.Show a_35 => GHC.Show.Show (Type a_35)
  
  instance AST.Unmarshal.Unmarshal Type
  
  instance Data.Foldable.Foldable Type where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Type where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Type where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype UnannotatedType a = UnannotatedType {getUnannotatedType :: ((SimpleType GHC.Generics.:+: ArrayType) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_36.
        AST.Traversable1.Class.Traversable1 a_36
      )
  
  instance GHC.Records.HasField "ann" (UnannotatedType a_37) a_37 where
    getField = AST.Unmarshal.gann GHC.Base.. getUnannotatedType
  
  deriving instance GHC.Classes.Eq a_38 => GHC.Classes.Eq (UnannotatedType a_38)
  
  deriving instance GHC.Classes.Ord a_39 => GHC.Classes.Ord (UnannotatedType a_39)
  
  deriving instance GHC.Show.Show a_40 => GHC.Show.Show (UnannotatedType a_40)
  
  instance AST.Unmarshal.Unmarshal UnannotatedType
  
  instance Data.Foldable.Foldable UnannotatedType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnannotatedType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnannotatedType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotatedType a = AnnotatedType
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((UnannotatedType GHC.Generics.:+: Annotation GHC.Generics.:+: MarkerAnnotation) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_41.
        AST.Traversable1.Class.Traversable1 a_41
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotatedType where
    matchedSymbols _ = [227]
    showFailure _ node_42 =
      "expected "
        GHC.Base.<> ( "annotated_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_42 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_42) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_43 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_44 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_45 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_46 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_43
          c1_44 = TreeSitter.Node.nodeStartPoint node_42
        TreeSitter.Node.TSPoint
          r2_45
          c2_46 = TreeSitter.Node.nodeEndPoint node_42
  
  deriving instance GHC.Classes.Eq a_47 => GHC.Classes.Eq (AnnotatedType a_47)
  
  deriving instance GHC.Classes.Ord a_48 => GHC.Classes.Ord (AnnotatedType a_48)
  
  deriving instance GHC.Show.Show a_49 => GHC.Show.Show (AnnotatedType a_49)
  
  instance AST.Unmarshal.Unmarshal AnnotatedType
  
  instance Data.Foldable.Foldable AnnotatedType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotatedType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotatedType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Annotation a = Annotation
    { ann :: a,
      arguments :: (AST.Parse.Err (AnnotationArgumentList a)),
      name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: ScopedIdentifier) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_50.
        AST.Traversable1.Class.Traversable1 a_50
      )
  
  instance AST.Unmarshal.SymbolMatching Annotation where
    matchedSymbols _ = [180]
    showFailure _ node_51 =
      "expected "
        GHC.Base.<> ( "annotation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_51 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_51) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_52 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_53 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_54 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_55 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_52
          c1_53 = TreeSitter.Node.nodeStartPoint node_51
        TreeSitter.Node.TSPoint
          r2_54
          c2_55 = TreeSitter.Node.nodeEndPoint node_51
  
  deriving instance GHC.Classes.Eq a_56 => GHC.Classes.Eq (Annotation a_56)
  
  deriving instance GHC.Classes.Ord a_57 => GHC.Classes.Ord (Annotation a_57)
  
  deriving instance GHC.Show.Show a_58 => GHC.Show.Show (Annotation a_58)
  
  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 AnnotationArgumentList a = AnnotationArgumentList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: Annotation GHC.Generics.:+: ElementValueArrayInitializer GHC.Generics.:+: ElementValuePair GHC.Generics.:+: MarkerAnnotation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_59.
        AST.Traversable1.Class.Traversable1 a_59
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotationArgumentList where
    matchedSymbols _ = [181]
    showFailure _ node_60 =
      "expected "
        GHC.Base.<> ( "annotation_argument_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_60 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_60) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_61 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_62 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_63 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_64 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_61
          c1_62 = TreeSitter.Node.nodeStartPoint node_60
        TreeSitter.Node.TSPoint
          r2_63
          c2_64 = TreeSitter.Node.nodeEndPoint node_60
  
  deriving instance GHC.Classes.Eq a_65 => GHC.Classes.Eq (AnnotationArgumentList a_65)
  
  deriving instance GHC.Classes.Ord a_66 => GHC.Classes.Ord (AnnotationArgumentList a_66)
  
  deriving instance GHC.Show.Show a_67 => GHC.Show.Show (AnnotationArgumentList a_67)
  
  instance AST.Unmarshal.Unmarshal AnnotationArgumentList
  
  instance Data.Foldable.Foldable AnnotationArgumentList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotationArgumentList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotationArgumentList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotationTypeBody a = AnnotationTypeBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((AnnotationTypeDeclaration GHC.Generics.:+: AnnotationTypeElementDeclaration GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: ConstantDeclaration GHC.Generics.:+: InterfaceDeclaration) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_68.
        AST.Traversable1.Class.Traversable1 a_68
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotationTypeBody where
    matchedSymbols _ = [214]
    showFailure _ node_69 =
      "expected "
        GHC.Base.<> ( "annotation_type_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_69 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_69) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_70 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_71 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_72 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_73 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_70
          c1_71 = TreeSitter.Node.nodeStartPoint node_69
        TreeSitter.Node.TSPoint
          r2_72
          c2_73 = TreeSitter.Node.nodeEndPoint node_69
  
  deriving instance GHC.Classes.Eq a_74 => GHC.Classes.Eq (AnnotationTypeBody a_74)
  
  deriving instance GHC.Classes.Ord a_75 => GHC.Classes.Ord (AnnotationTypeBody a_75)
  
  deriving instance GHC.Show.Show a_76 => GHC.Show.Show (AnnotationTypeBody a_76)
  
  instance AST.Unmarshal.Unmarshal AnnotationTypeBody
  
  instance Data.Foldable.Foldable AnnotationTypeBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotationTypeBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotationTypeBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotationTypeDeclaration a = AnnotationTypeDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (AnnotationTypeBody a)),
      name :: (AST.Parse.Err (Identifier a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_77.
        AST.Traversable1.Class.Traversable1 a_77
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotationTypeDeclaration where
    matchedSymbols _ = [213]
    showFailure _ node_78 =
      "expected "
        GHC.Base.<> ( "annotation_type_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_78 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_78) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_79 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_80 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_81 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_82 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_79
          c1_80 = TreeSitter.Node.nodeStartPoint node_78
        TreeSitter.Node.TSPoint
          r2_81
          c2_82 = TreeSitter.Node.nodeEndPoint node_78
  
  deriving instance GHC.Classes.Eq a_83 => GHC.Classes.Eq (AnnotationTypeDeclaration a_83)
  
  deriving instance GHC.Classes.Ord a_84 => GHC.Classes.Ord (AnnotationTypeDeclaration a_84)
  
  deriving instance GHC.Show.Show a_85 => GHC.Show.Show (AnnotationTypeDeclaration a_85)
  
  instance AST.Unmarshal.Unmarshal AnnotationTypeDeclaration
  
  instance Data.Foldable.Foldable AnnotationTypeDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotationTypeDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotationTypeDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnnotationTypeElementDeclaration a = AnnotationTypeElementDeclaration
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: Annotation GHC.Generics.:+: ElementValueArrayInitializer GHC.Generics.:+: MarkerAnnotation) a))),
      name :: (AST.Parse.Err (Identifier a)),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_86.
        AST.Traversable1.Class.Traversable1 a_86
      )
  
  instance AST.Unmarshal.SymbolMatching AnnotationTypeElementDeclaration where
    matchedSymbols _ = [215]
    showFailure _ node_87 =
      "expected "
        GHC.Base.<> ( "annotation_type_element_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_87 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_87) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_88 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_89 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_90 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_91 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_88
          c1_89 = TreeSitter.Node.nodeStartPoint node_87
        TreeSitter.Node.TSPoint
          r2_90
          c2_91 = TreeSitter.Node.nodeEndPoint node_87
  
  deriving instance GHC.Classes.Eq a_92 => GHC.Classes.Eq (AnnotationTypeElementDeclaration a_92)
  
  deriving instance GHC.Classes.Ord a_93 => GHC.Classes.Ord (AnnotationTypeElementDeclaration a_93)
  
  deriving instance GHC.Show.Show a_94 => GHC.Show.Show (AnnotationTypeElementDeclaration a_94)
  
  instance AST.Unmarshal.Unmarshal AnnotationTypeElementDeclaration
  
  instance Data.Foldable.Foldable AnnotationTypeElementDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnnotationTypeElementDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnnotationTypeElementDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArgumentList a = ArgumentList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Expression a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_95.
        AST.Traversable1.Class.Traversable1 a_95
      )
  
  instance AST.Unmarshal.SymbolMatching ArgumentList where
    matchedSymbols _ = [145]
    showFailure _ node_96 =
      "expected "
        GHC.Base.<> ( "argument_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_96 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_96) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_97 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_98 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_99 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_100 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_97
          c1_98 = TreeSitter.Node.nodeStartPoint node_96
        TreeSitter.Node.TSPoint
          r2_99
          c2_100 = TreeSitter.Node.nodeEndPoint node_96
  
  deriving instance GHC.Classes.Eq a_101 => GHC.Classes.Eq (ArgumentList a_101)
  
  deriving instance GHC.Classes.Ord a_102 => GHC.Classes.Ord (ArgumentList a_102)
  
  deriving instance GHC.Show.Show a_103 => GHC.Show.Show (ArgumentList a_103)
  
  instance AST.Unmarshal.Unmarshal ArgumentList
  
  instance Data.Foldable.Foldable ArgumentList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArgumentList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArgumentList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArrayAccess a = ArrayAccess
    { ann :: a,
      array :: (AST.Parse.Err ((Primary GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier) a)),
      index :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_104.
        AST.Traversable1.Class.Traversable1 a_104
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayAccess where
    matchedSymbols _ = [143]
    showFailure _ node_105 =
      "expected "
        GHC.Base.<> ( "array_access"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_105 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_105) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_106 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_107 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_108 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_109 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_106
          c1_107 = TreeSitter.Node.nodeStartPoint node_105
        TreeSitter.Node.TSPoint
          r2_108
          c2_109 = TreeSitter.Node.nodeEndPoint node_105
  
  deriving instance GHC.Classes.Eq a_110 => GHC.Classes.Eq (ArrayAccess a_110)
  
  deriving instance GHC.Classes.Ord a_111 => GHC.Classes.Ord (ArrayAccess a_111)
  
  deriving instance GHC.Show.Show a_112 => GHC.Show.Show (ArrayAccess a_112)
  
  instance AST.Unmarshal.Unmarshal ArrayAccess
  
  instance Data.Foldable.Foldable ArrayAccess where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArrayAccess where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArrayAccess where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArrayCreationExpression a = ArrayCreationExpression
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err (ArrayInitializer a))),
      type' :: (AST.Parse.Err (SimpleType a)),
      dimensions :: (GHC.Base.NonEmpty (AST.Parse.Err ((Dimensions GHC.Generics.:+: DimensionsExpr) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_113.
        AST.Traversable1.Class.Traversable1 a_113
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayCreationExpression where
    matchedSymbols _ = [136]
    showFailure _ node_114 =
      "expected "
        GHC.Base.<> ( "array_creation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_114 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_114) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_115 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_116 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_117 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_118 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_115
          c1_116 = TreeSitter.Node.nodeStartPoint node_114
        TreeSitter.Node.TSPoint
          r2_117
          c2_118 = TreeSitter.Node.nodeEndPoint node_114
  
  deriving instance GHC.Classes.Eq a_119 => GHC.Classes.Eq (ArrayCreationExpression a_119)
  
  deriving instance GHC.Classes.Ord a_120 => GHC.Classes.Ord (ArrayCreationExpression a_120)
  
  deriving instance GHC.Show.Show a_121 => GHC.Show.Show (ArrayCreationExpression a_121)
  
  instance AST.Unmarshal.Unmarshal ArrayCreationExpression
  
  instance Data.Foldable.Foldable ArrayCreationExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArrayCreationExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArrayCreationExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArrayInitializer a = ArrayInitializer
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: ArrayInitializer) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_122.
        AST.Traversable1.Class.Traversable1 a_122
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayInitializer where
    matchedSymbols _ = [224]
    showFailure _ node_123 =
      "expected "
        GHC.Base.<> ( "array_initializer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_123 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_123) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_124 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_125 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_126 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_127 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_124
          c1_125 = TreeSitter.Node.nodeStartPoint node_123
        TreeSitter.Node.TSPoint
          r2_126
          c2_127 = TreeSitter.Node.nodeEndPoint node_123
  
  deriving instance GHC.Classes.Eq a_128 => GHC.Classes.Eq (ArrayInitializer a_128)
  
  deriving instance GHC.Classes.Ord a_129 => GHC.Classes.Ord (ArrayInitializer a_129)
  
  deriving instance GHC.Show.Show a_130 => GHC.Show.Show (ArrayInitializer a_130)
  
  instance AST.Unmarshal.Unmarshal ArrayInitializer
  
  instance Data.Foldable.Foldable ArrayInitializer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArrayInitializer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArrayInitializer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArrayType a = ArrayType
    { ann :: a,
      dimensions :: (AST.Parse.Err (Dimensions a)),
      element :: (AST.Parse.Err (UnannotatedType a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_131.
        AST.Traversable1.Class.Traversable1 a_131
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayType where
    matchedSymbols _ = [230]
    showFailure _ node_132 =
      "expected "
        GHC.Base.<> ( "array_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_132 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_132) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_133 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_134 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_135 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_136 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_133
          c1_134 = TreeSitter.Node.nodeStartPoint node_132
        TreeSitter.Node.TSPoint
          r2_135
          c2_136 = TreeSitter.Node.nodeEndPoint node_132
  
  deriving instance GHC.Classes.Eq a_137 => GHC.Classes.Eq (ArrayType a_137)
  
  deriving instance GHC.Classes.Ord a_138 => GHC.Classes.Ord (ArrayType a_138)
  
  deriving instance GHC.Show.Show a_139 => GHC.Show.Show (ArrayType a_139)
  
  instance AST.Unmarshal.Unmarshal ArrayType
  
  instance Data.Foldable.Foldable ArrayType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArrayType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArrayType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AssertStatement a = AssertStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_140.
        AST.Traversable1.Class.Traversable1 a_140
      )
  
  instance AST.Unmarshal.SymbolMatching AssertStatement where
    matchedSymbols _ = [155]
    showFailure _ node_141 =
      "expected "
        GHC.Base.<> ( "assert_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_141 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_141) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_142 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_143 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_144 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_145 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_142
          c1_143 = TreeSitter.Node.nodeStartPoint node_141
        TreeSitter.Node.TSPoint
          r2_144
          c2_145 = TreeSitter.Node.nodeEndPoint node_141
  
  deriving instance GHC.Classes.Eq a_146 => GHC.Classes.Eq (AssertStatement a_146)
  
  deriving instance GHC.Classes.Ord a_147 => GHC.Classes.Ord (AssertStatement a_147)
  
  deriving instance GHC.Show.Show a_148 => GHC.Show.Show (AssertStatement a_148)
  
  instance AST.Unmarshal.Unmarshal AssertStatement
  
  instance Data.Foldable.Foldable AssertStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AssertStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AssertStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AssignmentExpression a = AssignmentExpression
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousPercentEqual GHC.Generics.:+: AnonymousAmpersandEqual GHC.Generics.:+: AnonymousStarEqual GHC.Generics.:+: AnonymousPlusEqual GHC.Generics.:+: AnonymousMinusEqual GHC.Generics.:+: AnonymousSlashEqual GHC.Generics.:+: AnonymousLAngleLAngleEqual GHC.Generics.:+: AnonymousEqual GHC.Generics.:+: AnonymousRAngleRAngleEqual GHC.Generics.:+: AnonymousRAngleRAngleRAngleEqual GHC.Generics.:+: AnonymousCaretEqual GHC.Generics.:+: AnonymousPipeEqual) a)),
      left :: (AST.Parse.Err ((ArrayAccess GHC.Generics.:+: FieldAccess GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier) a)),
      right :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_149.
        AST.Traversable1.Class.Traversable1 a_149
      )
  
  instance AST.Unmarshal.SymbolMatching AssignmentExpression where
    matchedSymbols _ = [127]
    showFailure _ node_150 =
      "expected "
        GHC.Base.<> ( "assignment_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_150 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_150) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_151 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_152 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_153 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_154 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_151
          c1_152 = TreeSitter.Node.nodeStartPoint node_150
        TreeSitter.Node.TSPoint
          r2_153
          c2_154 = TreeSitter.Node.nodeEndPoint node_150
  
  deriving instance GHC.Classes.Eq a_155 => GHC.Classes.Eq (AssignmentExpression a_155)
  
  deriving instance GHC.Classes.Ord a_156 => GHC.Classes.Ord (AssignmentExpression a_156)
  
  deriving instance GHC.Show.Show a_157 => GHC.Show.Show (AssignmentExpression a_157)
  
  instance AST.Unmarshal.Unmarshal AssignmentExpression
  
  instance Data.Foldable.Foldable AssignmentExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AssignmentExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AssignmentExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Asterisk a = Asterisk {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_158.
        AST.Traversable1.Class.Traversable1 a_158
      )
  
  instance AST.Unmarshal.SymbolMatching Asterisk where
    matchedSymbols _ = [192]
    showFailure _ node_159 =
      "expected "
        GHC.Base.<> ( "asterisk"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_159 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_159) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_160 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_161 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_162 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_163 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_160
          c1_161 = TreeSitter.Node.nodeStartPoint node_159
        TreeSitter.Node.TSPoint
          r2_162
          c2_163 = TreeSitter.Node.nodeEndPoint node_159
  
  deriving instance GHC.Classes.Eq a_164 => GHC.Classes.Eq (Asterisk a_164)
  
  deriving instance GHC.Classes.Ord a_165 => GHC.Classes.Ord (Asterisk a_165)
  
  deriving instance GHC.Show.Show a_166 => GHC.Show.Show (Asterisk a_166)
  
  instance AST.Unmarshal.Unmarshal Asterisk
  
  instance Data.Foldable.Foldable Asterisk where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Asterisk where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Asterisk where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BinaryExpression a = BinaryExpression
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousBangEqual GHC.Generics.:+: AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousAmpersandAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousLAngle GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousLAngleEqual GHC.Generics.:+: AnonymousEqualEqual GHC.Generics.:+: AnonymousRAngle GHC.Generics.:+: AnonymousRAngleEqual GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousRAngleRAngleRAngle GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousPipe GHC.Generics.:+: AnonymousPipePipe) a)),
      left :: (AST.Parse.Err (Expression a)),
      right :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_167.
        AST.Traversable1.Class.Traversable1 a_167
      )
  
  instance AST.Unmarshal.SymbolMatching BinaryExpression where
    matchedSymbols _ = [128]
    showFailure _ node_168 =
      "expected "
        GHC.Base.<> ( "binary_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_168 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_168) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_169 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_170 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_171 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_172 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_169
          c1_170 = TreeSitter.Node.nodeStartPoint node_168
        TreeSitter.Node.TSPoint
          r2_171
          c2_172 = TreeSitter.Node.nodeEndPoint node_168
  
  deriving instance GHC.Classes.Eq a_173 => GHC.Classes.Eq (BinaryExpression a_173)
  
  deriving instance GHC.Classes.Ord a_174 => GHC.Classes.Ord (BinaryExpression a_174)
  
  deriving instance GHC.Show.Show a_175 => GHC.Show.Show (BinaryExpression a_175)
  
  instance AST.Unmarshal.Unmarshal BinaryExpression
  
  instance Data.Foldable.Foldable BinaryExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BinaryExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BinaryExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Block a = Block
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_176.
        AST.Traversable1.Class.Traversable1 a_176
      )
  
  instance AST.Unmarshal.SymbolMatching Block where
    matchedSymbols _ = [152]
    showFailure _ node_177 =
      "expected "
        GHC.Base.<> ( "block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_177 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_177) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_178 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_179 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_180 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_181 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_178
          c1_179 = TreeSitter.Node.nodeStartPoint node_177
        TreeSitter.Node.TSPoint
          r2_180
          c2_181 = TreeSitter.Node.nodeEndPoint node_177
  
  deriving instance GHC.Classes.Eq a_182 => GHC.Classes.Eq (Block a_182)
  
  deriving instance GHC.Classes.Ord a_183 => GHC.Classes.Ord (Block a_183)
  
  deriving instance GHC.Show.Show a_184 => GHC.Show.Show (Block a_184)
  
  instance AST.Unmarshal.Unmarshal Block
  
  instance Data.Foldable.Foldable Block where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Block where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Block where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BreakStatement a = BreakStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_185.
        AST.Traversable1.Class.Traversable1 a_185
      )
  
  instance AST.Unmarshal.SymbolMatching BreakStatement where
    matchedSymbols _ = [160]
    showFailure _ node_186 =
      "expected "
        GHC.Base.<> ( "break_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_186 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_186) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_187 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_188 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_189 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_190 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_187
          c1_188 = TreeSitter.Node.nodeStartPoint node_186
        TreeSitter.Node.TSPoint
          r2_189
          c2_190 = TreeSitter.Node.nodeEndPoint node_186
  
  deriving instance GHC.Classes.Eq a_191 => GHC.Classes.Eq (BreakStatement a_191)
  
  deriving instance GHC.Classes.Ord a_192 => GHC.Classes.Ord (BreakStatement a_192)
  
  deriving instance GHC.Show.Show a_193 => GHC.Show.Show (BreakStatement a_193)
  
  instance AST.Unmarshal.Unmarshal BreakStatement
  
  instance Data.Foldable.Foldable BreakStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BreakStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BreakStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CastExpression a = CastExpression
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      type' :: (GHC.Base.NonEmpty (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_194.
        AST.Traversable1.Class.Traversable1 a_194
      )
  
  instance AST.Unmarshal.SymbolMatching CastExpression where
    matchedSymbols _ = [126]
    showFailure _ node_195 =
      "expected "
        GHC.Base.<> ( "cast_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_195 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_195) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_196 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_197 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_198 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_199 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_196
          c1_197 = TreeSitter.Node.nodeStartPoint node_195
        TreeSitter.Node.TSPoint
          r2_198
          c2_199 = TreeSitter.Node.nodeEndPoint node_195
  
  deriving instance GHC.Classes.Eq a_200 => GHC.Classes.Eq (CastExpression a_200)
  
  deriving instance GHC.Classes.Ord a_201 => GHC.Classes.Ord (CastExpression a_201)
  
  deriving instance GHC.Show.Show a_202 => GHC.Show.Show (CastExpression a_202)
  
  instance AST.Unmarshal.Unmarshal CastExpression
  
  instance Data.Foldable.Foldable CastExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CastExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CastExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CatchClause a = CatchClause
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      extraChildren :: (AST.Parse.Err (CatchFormalParameter a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_203.
        AST.Traversable1.Class.Traversable1 a_203
      )
  
  instance AST.Unmarshal.SymbolMatching CatchClause where
    matchedSymbols _ = [166]
    showFailure _ node_204 =
      "expected "
        GHC.Base.<> ( "catch_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_204 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_204) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_205 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_206 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_207 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_208 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_205
          c1_206 = TreeSitter.Node.nodeStartPoint node_204
        TreeSitter.Node.TSPoint
          r2_207
          c2_208 = TreeSitter.Node.nodeEndPoint node_204
  
  deriving instance GHC.Classes.Eq a_209 => GHC.Classes.Eq (CatchClause a_209)
  
  deriving instance GHC.Classes.Ord a_210 => GHC.Classes.Ord (CatchClause a_210)
  
  deriving instance GHC.Show.Show a_211 => GHC.Show.Show (CatchClause a_211)
  
  instance AST.Unmarshal.Unmarshal CatchClause
  
  instance Data.Foldable.Foldable CatchClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CatchClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CatchClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CatchFormalParameter a = CatchFormalParameter
    { ann :: a,
      name :: (AST.Parse.Err (Identifier a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((CatchType GHC.Generics.:+: Modifiers) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_212.
        AST.Traversable1.Class.Traversable1 a_212
      )
  
  instance AST.Unmarshal.SymbolMatching CatchFormalParameter where
    matchedSymbols _ = [167]
    showFailure _ node_213 =
      "expected "
        GHC.Base.<> ( "catch_formal_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_213 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_213) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_214 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_215 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_216 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_217 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_214
          c1_215 = TreeSitter.Node.nodeStartPoint node_213
        TreeSitter.Node.TSPoint
          r2_216
          c2_217 = TreeSitter.Node.nodeEndPoint node_213
  
  deriving instance GHC.Classes.Eq a_218 => GHC.Classes.Eq (CatchFormalParameter a_218)
  
  deriving instance GHC.Classes.Ord a_219 => GHC.Classes.Ord (CatchFormalParameter a_219)
  
  deriving instance GHC.Show.Show a_220 => GHC.Show.Show (CatchFormalParameter a_220)
  
  instance AST.Unmarshal.Unmarshal CatchFormalParameter
  
  instance Data.Foldable.Foldable CatchFormalParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CatchFormalParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CatchFormalParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CatchType a = CatchType
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (UnannotatedType a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_221.
        AST.Traversable1.Class.Traversable1 a_221
      )
  
  instance AST.Unmarshal.SymbolMatching CatchType where
    matchedSymbols _ = [168]
    showFailure _ node_222 =
      "expected "
        GHC.Base.<> ( "catch_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_222 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_222) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_223 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_224 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_225 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_226 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_223
          c1_224 = TreeSitter.Node.nodeStartPoint node_222
        TreeSitter.Node.TSPoint
          r2_225
          c2_226 = TreeSitter.Node.nodeEndPoint node_222
  
  deriving instance GHC.Classes.Eq a_227 => GHC.Classes.Eq (CatchType a_227)
  
  deriving instance GHC.Classes.Ord a_228 => GHC.Classes.Ord (CatchType a_228)
  
  deriving instance GHC.Show.Show a_229 => GHC.Show.Show (CatchType a_229)
  
  instance AST.Unmarshal.Unmarshal CatchType
  
  instance Data.Foldable.Foldable CatchType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CatchType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CatchType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassBody a = ClassBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((AnnotationTypeDeclaration GHC.Generics.:+: Block GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: ConstructorDeclaration GHC.Generics.:+: EnumDeclaration GHC.Generics.:+: FieldDeclaration GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: MethodDeclaration GHC.Generics.:+: StaticInitializer) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_230.
        AST.Traversable1.Class.Traversable1 a_230
      )
  
  instance AST.Unmarshal.SymbolMatching ClassBody where
    matchedSymbols _ = [205]
    showFailure _ node_231 =
      "expected "
        GHC.Base.<> ( "class_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_231 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_231) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_232 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_233 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_234 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_235 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_232
          c1_233 = TreeSitter.Node.nodeStartPoint node_231
        TreeSitter.Node.TSPoint
          r2_234
          c2_235 = TreeSitter.Node.nodeEndPoint node_231
  
  deriving instance GHC.Classes.Eq a_236 => GHC.Classes.Eq (ClassBody a_236)
  
  deriving instance GHC.Classes.Ord a_237 => GHC.Classes.Ord (ClassBody a_237)
  
  deriving instance GHC.Show.Show a_238 => GHC.Show.Show (ClassBody a_238)
  
  instance AST.Unmarshal.Unmarshal ClassBody
  
  instance Data.Foldable.Foldable ClassBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassDeclaration a = ClassDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (ClassBody a)),
      interfaces :: (GHC.Maybe.Maybe (AST.Parse.Err (SuperInterfaces a))),
      name :: (AST.Parse.Err (Identifier a)),
      superclass :: (GHC.Maybe.Maybe (AST.Parse.Err (Superclass a))),
      typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_239.
        AST.Traversable1.Class.Traversable1 a_239
      )
  
  instance AST.Unmarshal.SymbolMatching ClassDeclaration where
    matchedSymbols _ = [197]
    showFailure _ node_240 =
      "expected "
        GHC.Base.<> ( "class_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_240 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_240) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_241 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_242 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_243 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_244 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_241
          c1_242 = TreeSitter.Node.nodeStartPoint node_240
        TreeSitter.Node.TSPoint
          r2_243
          c2_244 = TreeSitter.Node.nodeEndPoint node_240
  
  deriving instance GHC.Classes.Eq a_245 => GHC.Classes.Eq (ClassDeclaration a_245)
  
  deriving instance GHC.Classes.Ord a_246 => GHC.Classes.Ord (ClassDeclaration a_246)
  
  deriving instance GHC.Show.Show a_247 => GHC.Show.Show (ClassDeclaration a_247)
  
  instance AST.Unmarshal.Unmarshal ClassDeclaration
  
  instance Data.Foldable.Foldable ClassDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassLiteral a = ClassLiteral
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((BooleanType GHC.Generics.:+: FloatingPointType GHC.Generics.:+: Identifier GHC.Generics.:+: IntegralType GHC.Generics.:+: ScopedIdentifier GHC.Generics.:+: VoidType) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_248.
        AST.Traversable1.Class.Traversable1 a_248
      )
  
  instance AST.Unmarshal.SymbolMatching ClassLiteral where
    matchedSymbols _ = [139]
    showFailure _ node_249 =
      "expected "
        GHC.Base.<> ( "class_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_249 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_249) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_250 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_251 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_252 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_253 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_250
          c1_251 = TreeSitter.Node.nodeStartPoint node_249
        TreeSitter.Node.TSPoint
          r2_252
          c2_253 = TreeSitter.Node.nodeEndPoint node_249
  
  deriving instance GHC.Classes.Eq a_254 => GHC.Classes.Eq (ClassLiteral a_254)
  
  deriving instance GHC.Classes.Ord a_255 => GHC.Classes.Ord (ClassLiteral a_255)
  
  deriving instance GHC.Show.Show a_256 => GHC.Show.Show (ClassLiteral a_256)
  
  instance AST.Unmarshal.Unmarshal ClassLiteral
  
  instance Data.Foldable.Foldable ClassLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConstantDeclaration a = ConstantDeclaration
    { ann :: a,
      declarator :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableDeclarator a))),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_257.
        AST.Traversable1.Class.Traversable1 a_257
      )
  
  instance AST.Unmarshal.SymbolMatching ConstantDeclaration where
    matchedSymbols _ = [220]
    showFailure _ node_258 =
      "expected "
        GHC.Base.<> ( "constant_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_258 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_258) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_259 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_260 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_261 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_262 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_259
          c1_260 = TreeSitter.Node.nodeStartPoint node_258
        TreeSitter.Node.TSPoint
          r2_261
          c2_262 = TreeSitter.Node.nodeEndPoint node_258
  
  deriving instance GHC.Classes.Eq a_263 => GHC.Classes.Eq (ConstantDeclaration a_263)
  
  deriving instance GHC.Classes.Ord a_264 => GHC.Classes.Ord (ConstantDeclaration a_264)
  
  deriving instance GHC.Show.Show a_265 => GHC.Show.Show (ConstantDeclaration a_265)
  
  instance AST.Unmarshal.Unmarshal ConstantDeclaration
  
  instance Data.Foldable.Foldable ConstantDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConstantDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConstantDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConstructorBody a = ConstructorBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: ExplicitConstructorInvocation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_266.
        AST.Traversable1.Class.Traversable1 a_266
      )
  
  instance AST.Unmarshal.SymbolMatching ConstructorBody where
    matchedSymbols _ = [209]
    showFailure _ node_267 =
      "expected "
        GHC.Base.<> ( "constructor_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_267 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_267) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_268 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_269 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_270 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_271 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_268
          c1_269 = TreeSitter.Node.nodeStartPoint node_267
        TreeSitter.Node.TSPoint
          r2_270
          c2_271 = TreeSitter.Node.nodeEndPoint node_267
  
  deriving instance GHC.Classes.Eq a_272 => GHC.Classes.Eq (ConstructorBody a_272)
  
  deriving instance GHC.Classes.Ord a_273 => GHC.Classes.Ord (ConstructorBody a_273)
  
  deriving instance GHC.Show.Show a_274 => GHC.Show.Show (ConstructorBody a_274)
  
  instance AST.Unmarshal.Unmarshal ConstructorBody
  
  instance Data.Foldable.Foldable ConstructorBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConstructorBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConstructorBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConstructorDeclaration a = ConstructorDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (ConstructorBody a)),
      typeParamaters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
      name :: (AST.Parse.Err (Identifier a)),
      parameters :: (AST.Parse.Err (FormalParameters a)),
      extraChildren :: ([AST.Parse.Err ((Modifiers GHC.Generics.:+: Throws) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_275.
        AST.Traversable1.Class.Traversable1 a_275
      )
  
  instance AST.Unmarshal.SymbolMatching ConstructorDeclaration where
    matchedSymbols _ = [207]
    showFailure _ node_276 =
      "expected "
        GHC.Base.<> ( "constructor_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_276 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_276) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_277 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_278 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_279 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_280 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_277
          c1_278 = TreeSitter.Node.nodeStartPoint node_276
        TreeSitter.Node.TSPoint
          r2_279
          c2_280 = TreeSitter.Node.nodeEndPoint node_276
  
  deriving instance GHC.Classes.Eq a_281 => GHC.Classes.Eq (ConstructorDeclaration a_281)
  
  deriving instance GHC.Classes.Ord a_282 => GHC.Classes.Ord (ConstructorDeclaration a_282)
  
  deriving instance GHC.Show.Show a_283 => GHC.Show.Show (ConstructorDeclaration a_283)
  
  instance AST.Unmarshal.Unmarshal ConstructorDeclaration
  
  instance Data.Foldable.Foldable ConstructorDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConstructorDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConstructorDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ContinueStatement a = ContinueStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_284.
        AST.Traversable1.Class.Traversable1 a_284
      )
  
  instance AST.Unmarshal.SymbolMatching ContinueStatement where
    matchedSymbols _ = [161]
    showFailure _ node_285 =
      "expected "
        GHC.Base.<> ( "continue_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_285 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_285) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_286 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_287 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_288 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_289 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_286
          c1_287 = TreeSitter.Node.nodeStartPoint node_285
        TreeSitter.Node.TSPoint
          r2_288
          c2_289 = TreeSitter.Node.nodeEndPoint node_285
  
  deriving instance GHC.Classes.Eq a_290 => GHC.Classes.Eq (ContinueStatement a_290)
  
  deriving instance GHC.Classes.Ord a_291 => GHC.Classes.Ord (ContinueStatement a_291)
  
  deriving instance GHC.Show.Show a_292 => GHC.Show.Show (ContinueStatement a_292)
  
  instance AST.Unmarshal.Unmarshal ContinueStatement
  
  instance Data.Foldable.Foldable ContinueStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ContinueStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ContinueStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Dimensions a = Dimensions
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Annotation GHC.Generics.:+: MarkerAnnotation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_293.
        AST.Traversable1.Class.Traversable1 a_293
      )
  
  instance AST.Unmarshal.SymbolMatching Dimensions where
    matchedSymbols _ = [150]
    showFailure _ node_294 =
      "expected "
        GHC.Base.<> ( "dimensions"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_294 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_294) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_295 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_296 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_297 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_298 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_295
          c1_296 = TreeSitter.Node.nodeStartPoint node_294
        TreeSitter.Node.TSPoint
          r2_297
          c2_298 = TreeSitter.Node.nodeEndPoint node_294
  
  deriving instance GHC.Classes.Eq a_299 => GHC.Classes.Eq (Dimensions a_299)
  
  deriving instance GHC.Classes.Ord a_300 => GHC.Classes.Ord (Dimensions a_300)
  
  deriving instance GHC.Show.Show a_301 => GHC.Show.Show (Dimensions a_301)
  
  instance AST.Unmarshal.Unmarshal Dimensions
  
  instance Data.Foldable.Foldable Dimensions where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Dimensions where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Dimensions where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DimensionsExpr a = DimensionsExpr
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Annotation GHC.Generics.:+: MarkerAnnotation) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_302.
        AST.Traversable1.Class.Traversable1 a_302
      )
  
  instance AST.Unmarshal.SymbolMatching DimensionsExpr where
    matchedSymbols _ = [137]
    showFailure _ node_303 =
      "expected "
        GHC.Base.<> ( "dimensions_expr"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_303 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_303) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_304 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_305 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_306 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_307 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_304
          c1_305 = TreeSitter.Node.nodeStartPoint node_303
        TreeSitter.Node.TSPoint
          r2_306
          c2_307 = TreeSitter.Node.nodeEndPoint node_303
  
  deriving instance GHC.Classes.Eq a_308 => GHC.Classes.Eq (DimensionsExpr a_308)
  
  deriving instance GHC.Classes.Ord a_309 => GHC.Classes.Ord (DimensionsExpr a_309)
  
  deriving instance GHC.Show.Show a_310 => GHC.Show.Show (DimensionsExpr a_310)
  
  instance AST.Unmarshal.Unmarshal DimensionsExpr
  
  instance Data.Foldable.Foldable DimensionsExpr where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DimensionsExpr where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DimensionsExpr where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DoStatement a = DoStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Statement) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_311.
        AST.Traversable1.Class.Traversable1 a_311
      )
  
  instance AST.Unmarshal.SymbolMatching DoStatement where
    matchedSymbols _ = [159]
    showFailure _ node_312 =
      "expected "
        GHC.Base.<> ( "do_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_312 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_312) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_313 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_314 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_315 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_316 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_313
          c1_314 = TreeSitter.Node.nodeStartPoint node_312
        TreeSitter.Node.TSPoint
          r2_315
          c2_316 = TreeSitter.Node.nodeEndPoint node_312
  
  deriving instance GHC.Classes.Eq a_317 => GHC.Classes.Eq (DoStatement a_317)
  
  deriving instance GHC.Classes.Ord a_318 => GHC.Classes.Ord (DoStatement a_318)
  
  deriving instance GHC.Show.Show a_319 => GHC.Show.Show (DoStatement a_319)
  
  instance AST.Unmarshal.Unmarshal DoStatement
  
  instance Data.Foldable.Foldable DoStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DoStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DoStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElementValueArrayInitializer a = ElementValueArrayInitializer
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: Annotation GHC.Generics.:+: ElementValueArrayInitializer GHC.Generics.:+: MarkerAnnotation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_320.
        AST.Traversable1.Class.Traversable1 a_320
      )
  
  instance AST.Unmarshal.SymbolMatching ElementValueArrayInitializer where
    matchedSymbols _ = [184]
    showFailure _ node_321 =
      "expected "
        GHC.Base.<> ( "element_value_array_initializer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_321 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_321) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_322 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_323 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_324 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_325 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_322
          c1_323 = TreeSitter.Node.nodeStartPoint node_321
        TreeSitter.Node.TSPoint
          r2_324
          c2_325 = TreeSitter.Node.nodeEndPoint node_321
  
  deriving instance GHC.Classes.Eq a_326 => GHC.Classes.Eq (ElementValueArrayInitializer a_326)
  
  deriving instance GHC.Classes.Ord a_327 => GHC.Classes.Ord (ElementValueArrayInitializer a_327)
  
  deriving instance GHC.Show.Show a_328 => GHC.Show.Show (ElementValueArrayInitializer a_328)
  
  instance AST.Unmarshal.Unmarshal ElementValueArrayInitializer
  
  instance Data.Foldable.Foldable ElementValueArrayInitializer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElementValueArrayInitializer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElementValueArrayInitializer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElementValuePair a = ElementValuePair
    { ann :: a,
      value :: (AST.Parse.Err ((Expression GHC.Generics.:+: Annotation GHC.Generics.:+: ElementValueArrayInitializer GHC.Generics.:+: MarkerAnnotation) a)),
      key :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_329.
        AST.Traversable1.Class.Traversable1 a_329
      )
  
  instance AST.Unmarshal.SymbolMatching ElementValuePair where
    matchedSymbols _ = [182]
    showFailure _ node_330 =
      "expected "
        GHC.Base.<> ( "element_value_pair"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_330 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_330) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_331 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_332 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_333 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_334 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_331
          c1_332 = TreeSitter.Node.nodeStartPoint node_330
        TreeSitter.Node.TSPoint
          r2_333
          c2_334 = TreeSitter.Node.nodeEndPoint node_330
  
  deriving instance GHC.Classes.Eq a_335 => GHC.Classes.Eq (ElementValuePair a_335)
  
  deriving instance GHC.Classes.Ord a_336 => GHC.Classes.Ord (ElementValuePair a_336)
  
  deriving instance GHC.Show.Show a_337 => GHC.Show.Show (ElementValuePair a_337)
  
  instance AST.Unmarshal.Unmarshal ElementValuePair
  
  instance Data.Foldable.Foldable ElementValuePair where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElementValuePair where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElementValuePair where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EnhancedForStatement a = EnhancedForStatement
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      value :: (AST.Parse.Err (Expression a)),
      name :: (AST.Parse.Err (Identifier a)),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_338.
        AST.Traversable1.Class.Traversable1 a_338
      )
  
  instance AST.Unmarshal.SymbolMatching EnhancedForStatement where
    matchedSymbols _ = [177]
    showFailure _ node_339 =
      "expected "
        GHC.Base.<> ( "enhanced_for_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_339 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_339) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_340 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_341 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_342 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_343 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_340
          c1_341 = TreeSitter.Node.nodeStartPoint node_339
        TreeSitter.Node.TSPoint
          r2_342
          c2_343 = TreeSitter.Node.nodeEndPoint node_339
  
  deriving instance GHC.Classes.Eq a_344 => GHC.Classes.Eq (EnhancedForStatement a_344)
  
  deriving instance GHC.Classes.Ord a_345 => GHC.Classes.Ord (EnhancedForStatement a_345)
  
  deriving instance GHC.Show.Show a_346 => GHC.Show.Show (EnhancedForStatement a_346)
  
  instance AST.Unmarshal.Unmarshal EnhancedForStatement
  
  instance Data.Foldable.Foldable EnhancedForStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EnhancedForStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EnhancedForStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EnumBody a = EnumBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EnumBodyDeclarations GHC.Generics.:+: EnumConstant) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_347.
        AST.Traversable1.Class.Traversable1 a_347
      )
  
  instance AST.Unmarshal.SymbolMatching EnumBody where
    matchedSymbols _ = [194]
    showFailure _ node_348 =
      "expected "
        GHC.Base.<> ( "enum_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_348 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_348) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_349 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_350 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_351 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_352 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_349
          c1_350 = TreeSitter.Node.nodeStartPoint node_348
        TreeSitter.Node.TSPoint
          r2_351
          c2_352 = TreeSitter.Node.nodeEndPoint node_348
  
  deriving instance GHC.Classes.Eq a_353 => GHC.Classes.Eq (EnumBody a_353)
  
  deriving instance GHC.Classes.Ord a_354 => GHC.Classes.Ord (EnumBody a_354)
  
  deriving instance GHC.Show.Show a_355 => GHC.Show.Show (EnumBody a_355)
  
  instance AST.Unmarshal.Unmarshal EnumBody
  
  instance Data.Foldable.Foldable EnumBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EnumBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EnumBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EnumBodyDeclarations a = EnumBodyDeclarations
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((AnnotationTypeDeclaration GHC.Generics.:+: Block GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: ConstructorDeclaration GHC.Generics.:+: EnumDeclaration GHC.Generics.:+: FieldDeclaration GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: MethodDeclaration GHC.Generics.:+: StaticInitializer) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_356.
        AST.Traversable1.Class.Traversable1 a_356
      )
  
  instance AST.Unmarshal.SymbolMatching EnumBodyDeclarations where
    matchedSymbols _ = [195]
    showFailure _ node_357 =
      "expected "
        GHC.Base.<> ( "enum_body_declarations"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_357 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_357) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_358 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_359 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_360 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_361 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_358
          c1_359 = TreeSitter.Node.nodeStartPoint node_357
        TreeSitter.Node.TSPoint
          r2_360
          c2_361 = TreeSitter.Node.nodeEndPoint node_357
  
  deriving instance GHC.Classes.Eq a_362 => GHC.Classes.Eq (EnumBodyDeclarations a_362)
  
  deriving instance GHC.Classes.Ord a_363 => GHC.Classes.Ord (EnumBodyDeclarations a_363)
  
  deriving instance GHC.Show.Show a_364 => GHC.Show.Show (EnumBodyDeclarations a_364)
  
  instance AST.Unmarshal.Unmarshal EnumBodyDeclarations
  
  instance Data.Foldable.Foldable EnumBodyDeclarations where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EnumBodyDeclarations where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EnumBodyDeclarations where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EnumConstant a = EnumConstant
    { ann :: a,
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (ClassBody a))),
      arguments :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a))),
      name :: (AST.Parse.Err (Identifier a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_365.
        AST.Traversable1.Class.Traversable1 a_365
      )
  
  instance AST.Unmarshal.SymbolMatching EnumConstant where
    matchedSymbols _ = [196]
    showFailure _ node_366 =
      "expected "
        GHC.Base.<> ( "enum_constant"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_366 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_366) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_367 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_368 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_369 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_370 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_367
          c1_368 = TreeSitter.Node.nodeStartPoint node_366
        TreeSitter.Node.TSPoint
          r2_369
          c2_370 = TreeSitter.Node.nodeEndPoint node_366
  
  deriving instance GHC.Classes.Eq a_371 => GHC.Classes.Eq (EnumConstant a_371)
  
  deriving instance GHC.Classes.Ord a_372 => GHC.Classes.Ord (EnumConstant a_372)
  
  deriving instance GHC.Show.Show a_373 => GHC.Show.Show (EnumConstant a_373)
  
  instance AST.Unmarshal.Unmarshal EnumConstant
  
  instance Data.Foldable.Foldable EnumConstant where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EnumConstant where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EnumConstant where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EnumDeclaration a = EnumDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (EnumBody a)),
      interfaces :: (GHC.Maybe.Maybe (AST.Parse.Err (SuperInterfaces a))),
      name :: (AST.Parse.Err (Identifier a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_374.
        AST.Traversable1.Class.Traversable1 a_374
      )
  
  instance AST.Unmarshal.SymbolMatching EnumDeclaration where
    matchedSymbols _ = [193]
    showFailure _ node_375 =
      "expected "
        GHC.Base.<> ( "enum_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_375 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_375) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_376 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_377 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_378 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_379 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_376
          c1_377 = TreeSitter.Node.nodeStartPoint node_375
        TreeSitter.Node.TSPoint
          r2_378
          c2_379 = TreeSitter.Node.nodeEndPoint node_375
  
  deriving instance GHC.Classes.Eq a_380 => GHC.Classes.Eq (EnumDeclaration a_380)
  
  deriving instance GHC.Classes.Ord a_381 => GHC.Classes.Ord (EnumDeclaration a_381)
  
  deriving instance GHC.Show.Show a_382 => GHC.Show.Show (EnumDeclaration a_382)
  
  instance AST.Unmarshal.Unmarshal EnumDeclaration
  
  instance Data.Foldable.Foldable EnumDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EnumDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EnumDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExplicitConstructorInvocation a = ExplicitConstructorInvocation
    { ann :: a,
      arguments :: (AST.Parse.Err (ArgumentList a)),
      typeArguments :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeArguments a))),
      object :: (GHC.Maybe.Maybe (AST.Parse.Err ((Primary GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier) a))),
      constructor :: (AST.Parse.Err ((Super GHC.Generics.:+: This) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_383.
        AST.Traversable1.Class.Traversable1 a_383
      )
  
  instance AST.Unmarshal.SymbolMatching ExplicitConstructorInvocation where
    matchedSymbols _ = [210]
    showFailure _ node_384 =
      "expected "
        GHC.Base.<> ( "explicit_constructor_invocation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_384 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_384) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_385 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_386 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_387 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_388 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_385
          c1_386 = TreeSitter.Node.nodeStartPoint node_384
        TreeSitter.Node.TSPoint
          r2_387
          c2_388 = TreeSitter.Node.nodeEndPoint node_384
  
  deriving instance GHC.Classes.Eq a_389 => GHC.Classes.Eq (ExplicitConstructorInvocation a_389)
  
  deriving instance GHC.Classes.Ord a_390 => GHC.Classes.Ord (ExplicitConstructorInvocation a_390)
  
  deriving instance GHC.Show.Show a_391 => GHC.Show.Show (ExplicitConstructorInvocation a_391)
  
  instance AST.Unmarshal.Unmarshal ExplicitConstructorInvocation
  
  instance Data.Foldable.Foldable ExplicitConstructorInvocation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExplicitConstructorInvocation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExplicitConstructorInvocation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExpressionStatement a = ExpressionStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_392.
        AST.Traversable1.Class.Traversable1 a_392
      )
  
  instance AST.Unmarshal.SymbolMatching ExpressionStatement where
    matchedSymbols _ = [153]
    showFailure _ node_393 =
      "expected "
        GHC.Base.<> ( "expression_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_393 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_393) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_394 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_395 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_396 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_397 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_394
          c1_395 = TreeSitter.Node.nodeStartPoint node_393
        TreeSitter.Node.TSPoint
          r2_396
          c2_397 = TreeSitter.Node.nodeEndPoint node_393
  
  deriving instance GHC.Classes.Eq a_398 => GHC.Classes.Eq (ExpressionStatement a_398)
  
  deriving instance GHC.Classes.Ord a_399 => GHC.Classes.Ord (ExpressionStatement a_399)
  
  deriving instance GHC.Show.Show a_400 => GHC.Show.Show (ExpressionStatement a_400)
  
  instance AST.Unmarshal.Unmarshal ExpressionStatement
  
  instance Data.Foldable.Foldable ExpressionStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExpressionStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExpressionStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExtendsInterfaces a = ExtendsInterfaces
    { ann :: a,
      extraChildren :: (AST.Parse.Err (InterfaceTypeList a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_401.
        AST.Traversable1.Class.Traversable1 a_401
      )
  
  instance AST.Unmarshal.SymbolMatching ExtendsInterfaces where
    matchedSymbols _ = [218]
    showFailure _ node_402 =
      "expected "
        GHC.Base.<> ( "extends_interfaces"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_402 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_402) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_403 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_404 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_405 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_406 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_403
          c1_404 = TreeSitter.Node.nodeStartPoint node_402
        TreeSitter.Node.TSPoint
          r2_405
          c2_406 = TreeSitter.Node.nodeEndPoint node_402
  
  deriving instance GHC.Classes.Eq a_407 => GHC.Classes.Eq (ExtendsInterfaces a_407)
  
  deriving instance GHC.Classes.Ord a_408 => GHC.Classes.Ord (ExtendsInterfaces a_408)
  
  deriving instance GHC.Show.Show a_409 => GHC.Show.Show (ExtendsInterfaces a_409)
  
  instance AST.Unmarshal.Unmarshal ExtendsInterfaces
  
  instance Data.Foldable.Foldable ExtendsInterfaces where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExtendsInterfaces where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExtendsInterfaces where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FieldAccess a = FieldAccess
    { ann :: a,
      field :: (AST.Parse.Err ((Identifier GHC.Generics.:+: This) a)),
      object :: (AST.Parse.Err ((Primary GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier GHC.Generics.:+: Super) a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Super a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_410.
        AST.Traversable1.Class.Traversable1 a_410
      )
  
  instance AST.Unmarshal.SymbolMatching FieldAccess where
    matchedSymbols _ = [142]
    showFailure _ node_411 =
      "expected "
        GHC.Base.<> ( "field_access"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_411 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_411) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_412 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_413 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_414 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_415 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_412
          c1_413 = TreeSitter.Node.nodeStartPoint node_411
        TreeSitter.Node.TSPoint
          r2_414
          c2_415 = TreeSitter.Node.nodeEndPoint node_411
  
  deriving instance GHC.Classes.Eq a_416 => GHC.Classes.Eq (FieldAccess a_416)
  
  deriving instance GHC.Classes.Ord a_417 => GHC.Classes.Ord (FieldAccess a_417)
  
  deriving instance GHC.Show.Show a_418 => GHC.Show.Show (FieldAccess a_418)
  
  instance AST.Unmarshal.Unmarshal FieldAccess
  
  instance Data.Foldable.Foldable FieldAccess where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FieldAccess where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FieldAccess where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FieldDeclaration a = FieldDeclaration
    { ann :: a,
      declarator :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableDeclarator a))),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_419.
        AST.Traversable1.Class.Traversable1 a_419
      )
  
  instance AST.Unmarshal.SymbolMatching FieldDeclaration where
    matchedSymbols _ = [212]
    showFailure _ node_420 =
      "expected "
        GHC.Base.<> ( "field_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_420 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_420) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_421 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_422 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_423 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_424 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_421
          c1_422 = TreeSitter.Node.nodeStartPoint node_420
        TreeSitter.Node.TSPoint
          r2_423
          c2_424 = TreeSitter.Node.nodeEndPoint node_420
  
  deriving instance GHC.Classes.Eq a_425 => GHC.Classes.Eq (FieldDeclaration a_425)
  
  deriving instance GHC.Classes.Ord a_426 => GHC.Classes.Ord (FieldDeclaration a_426)
  
  deriving instance GHC.Show.Show a_427 => GHC.Show.Show (FieldDeclaration a_427)
  
  instance AST.Unmarshal.Unmarshal FieldDeclaration
  
  instance Data.Foldable.Foldable FieldDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FieldDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FieldDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FinallyClause a = FinallyClause
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Block a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_428.
        AST.Traversable1.Class.Traversable1 a_428
      )
  
  instance AST.Unmarshal.SymbolMatching FinallyClause where
    matchedSymbols _ = [169]
    showFailure _ node_429 =
      "expected "
        GHC.Base.<> ( "finally_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_429 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_429) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_430 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_431 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_432 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_433 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_430
          c1_431 = TreeSitter.Node.nodeStartPoint node_429
        TreeSitter.Node.TSPoint
          r2_432
          c2_433 = TreeSitter.Node.nodeEndPoint node_429
  
  deriving instance GHC.Classes.Eq a_434 => GHC.Classes.Eq (FinallyClause a_434)
  
  deriving instance GHC.Classes.Ord a_435 => GHC.Classes.Ord (FinallyClause a_435)
  
  deriving instance GHC.Show.Show a_436 => GHC.Show.Show (FinallyClause a_436)
  
  instance AST.Unmarshal.Unmarshal FinallyClause
  
  instance Data.Foldable.Foldable FinallyClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FinallyClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FinallyClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FloatingPointType a = FloatingPointType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_437.
        AST.Traversable1.Class.Traversable1 a_437
      )
  
  instance AST.Unmarshal.SymbolMatching FloatingPointType where
    matchedSymbols _ = [232]
    showFailure _ node_438 =
      "expected "
        GHC.Base.<> ( "floating_point_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_438 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_438) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_439 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_440 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_441 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_442 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_439
          c1_440 = TreeSitter.Node.nodeStartPoint node_438
        TreeSitter.Node.TSPoint
          r2_441
          c2_442 = TreeSitter.Node.nodeEndPoint node_438
  
  deriving instance GHC.Classes.Eq a_443 => GHC.Classes.Eq (FloatingPointType a_443)
  
  deriving instance GHC.Classes.Ord a_444 => GHC.Classes.Ord (FloatingPointType a_444)
  
  deriving instance GHC.Show.Show a_445 => GHC.Show.Show (FloatingPointType a_445)
  
  instance AST.Unmarshal.Unmarshal FloatingPointType
  
  instance Data.Foldable.Foldable FloatingPointType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FloatingPointType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FloatingPointType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ForInit a = ForInit
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: LocalVariableDeclaration) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_446.
        AST.Traversable1.Class.Traversable1 a_446
      )
  
  instance AST.Unmarshal.SymbolMatching ForInit where
    matchedSymbols _ = [176]
    showFailure _ node_447 =
      "expected "
        GHC.Base.<> ( "for_init"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_447 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_447) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_448 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_449 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_450 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_451 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_448
          c1_449 = TreeSitter.Node.nodeStartPoint node_447
        TreeSitter.Node.TSPoint
          r2_450
          c2_451 = TreeSitter.Node.nodeEndPoint node_447
  
  deriving instance GHC.Classes.Eq a_452 => GHC.Classes.Eq (ForInit a_452)
  
  deriving instance GHC.Classes.Ord a_453 => GHC.Classes.Ord (ForInit a_453)
  
  deriving instance GHC.Show.Show a_454 => GHC.Show.Show (ForInit a_454)
  
  instance AST.Unmarshal.Unmarshal ForInit
  
  instance Data.Foldable.Foldable ForInit where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ForInit where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ForInit where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ForStatement a = ForStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Statement GHC.Generics.:+: ForInit) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_455.
        AST.Traversable1.Class.Traversable1 a_455
      )
  
  instance AST.Unmarshal.SymbolMatching ForStatement where
    matchedSymbols _ = [175]
    showFailure _ node_456 =
      "expected "
        GHC.Base.<> ( "for_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_456 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_456) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_457 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_458 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_459 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_460 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_457
          c1_458 = TreeSitter.Node.nodeStartPoint node_456
        TreeSitter.Node.TSPoint
          r2_459
          c2_460 = TreeSitter.Node.nodeEndPoint node_456
  
  deriving instance GHC.Classes.Eq a_461 => GHC.Classes.Eq (ForStatement a_461)
  
  deriving instance GHC.Classes.Ord a_462 => GHC.Classes.Ord (ForStatement a_462)
  
  deriving instance GHC.Show.Show a_463 => GHC.Show.Show (ForStatement a_463)
  
  instance AST.Unmarshal.Unmarshal ForStatement
  
  instance Data.Foldable.Foldable ForStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ForStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ForStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FormalParameter a = FormalParameter
    { ann :: a,
      name :: (AST.Parse.Err (Identifier a)),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_464.
        AST.Traversable1.Class.Traversable1 a_464
      )
  
  instance AST.Unmarshal.SymbolMatching FormalParameter where
    matchedSymbols _ = [236]
    showFailure _ node_465 =
      "expected "
        GHC.Base.<> ( "formal_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_465 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_465) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_466 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_467 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_468 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_469 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_466
          c1_467 = TreeSitter.Node.nodeStartPoint node_465
        TreeSitter.Node.TSPoint
          r2_468
          c2_469 = TreeSitter.Node.nodeEndPoint node_465
  
  deriving instance GHC.Classes.Eq a_470 => GHC.Classes.Eq (FormalParameter a_470)
  
  deriving instance GHC.Classes.Ord a_471 => GHC.Classes.Ord (FormalParameter a_471)
  
  deriving instance GHC.Show.Show a_472 => GHC.Show.Show (FormalParameter a_472)
  
  instance AST.Unmarshal.Unmarshal FormalParameter
  
  instance Data.Foldable.Foldable FormalParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FormalParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FormalParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FormalParameters a = FormalParameters
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((FormalParameter GHC.Generics.:+: ReceiverParameter GHC.Generics.:+: SpreadParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_473.
        AST.Traversable1.Class.Traversable1 a_473
      )
  
  instance AST.Unmarshal.SymbolMatching FormalParameters where
    matchedSymbols _ = [235]
    showFailure _ node_474 =
      "expected "
        GHC.Base.<> ( "formal_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_474 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_474) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_475 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_476 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_477 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_478 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_475
          c1_476 = TreeSitter.Node.nodeStartPoint node_474
        TreeSitter.Node.TSPoint
          r2_477
          c2_478 = TreeSitter.Node.nodeEndPoint node_474
  
  deriving instance GHC.Classes.Eq a_479 => GHC.Classes.Eq (FormalParameters a_479)
  
  deriving instance GHC.Classes.Ord a_480 => GHC.Classes.Ord (FormalParameters a_480)
  
  deriving instance GHC.Show.Show a_481 => GHC.Show.Show (FormalParameters a_481)
  
  instance AST.Unmarshal.Unmarshal FormalParameters
  
  instance Data.Foldable.Foldable FormalParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FormalParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FormalParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data GenericType a = GenericType
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ScopedTypeIdentifier GHC.Generics.:+: TypeArguments GHC.Generics.:+: TypeIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_482.
        AST.Traversable1.Class.Traversable1 a_482
      )
  
  instance AST.Unmarshal.SymbolMatching GenericType where
    matchedSymbols _ = [229]
    showFailure _ node_483 =
      "expected "
        GHC.Base.<> ( "generic_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_483 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_483) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_484 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_485 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_486 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_487 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_484
          c1_485 = TreeSitter.Node.nodeStartPoint node_483
        TreeSitter.Node.TSPoint
          r2_486
          c2_487 = TreeSitter.Node.nodeEndPoint node_483
  
  deriving instance GHC.Classes.Eq a_488 => GHC.Classes.Eq (GenericType a_488)
  
  deriving instance GHC.Classes.Ord a_489 => GHC.Classes.Ord (GenericType a_489)
  
  deriving instance GHC.Show.Show a_490 => GHC.Show.Show (GenericType a_490)
  
  instance AST.Unmarshal.Unmarshal GenericType
  
  instance Data.Foldable.Foldable GenericType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GenericType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GenericType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfStatement a = IfStatement
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err (Statement a))),
      consequence :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_491.
        AST.Traversable1.Class.Traversable1 a_491
      )
  
  instance AST.Unmarshal.SymbolMatching IfStatement where
    matchedSymbols _ = [173]
    showFailure _ node_492 =
      "expected "
        GHC.Base.<> ( "if_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_492 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_492) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_493 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_494 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_495 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_496 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_493
          c1_494 = TreeSitter.Node.nodeStartPoint node_492
        TreeSitter.Node.TSPoint
          r2_495
          c2_496 = TreeSitter.Node.nodeEndPoint node_492
  
  deriving instance GHC.Classes.Eq a_497 => GHC.Classes.Eq (IfStatement a_497)
  
  deriving instance GHC.Classes.Ord a_498 => GHC.Classes.Ord (IfStatement a_498)
  
  deriving instance GHC.Show.Show a_499 => GHC.Show.Show (IfStatement a_499)
  
  instance AST.Unmarshal.Unmarshal IfStatement
  
  instance Data.Foldable.Foldable IfStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IfStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IfStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ImportDeclaration a = ImportDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Asterisk GHC.Generics.:+: Identifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_500.
        AST.Traversable1.Class.Traversable1 a_500
      )
  
  instance AST.Unmarshal.SymbolMatching ImportDeclaration where
    matchedSymbols _ = [191]
    showFailure _ node_501 =
      "expected "
        GHC.Base.<> ( "import_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_501 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_501) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_502 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_503 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_504 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_505 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_502
          c1_503 = TreeSitter.Node.nodeStartPoint node_501
        TreeSitter.Node.TSPoint
          r2_504
          c2_505 = TreeSitter.Node.nodeEndPoint node_501
  
  deriving instance GHC.Classes.Eq a_506 => GHC.Classes.Eq (ImportDeclaration a_506)
  
  deriving instance GHC.Classes.Ord a_507 => GHC.Classes.Ord (ImportDeclaration a_507)
  
  deriving instance GHC.Show.Show a_508 => GHC.Show.Show (ImportDeclaration a_508)
  
  instance AST.Unmarshal.Unmarshal ImportDeclaration
  
  instance Data.Foldable.Foldable ImportDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ImportDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ImportDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InferredParameters a = InferredParameters
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_509.
        AST.Traversable1.Class.Traversable1 a_509
      )
  
  instance AST.Unmarshal.SymbolMatching InferredParameters where
    matchedSymbols _ = [131]
    showFailure _ node_510 =
      "expected "
        GHC.Base.<> ( "inferred_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_510 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_510) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_511 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_512 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_513 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_514 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_511
          c1_512 = TreeSitter.Node.nodeStartPoint node_510
        TreeSitter.Node.TSPoint
          r2_513
          c2_514 = TreeSitter.Node.nodeEndPoint node_510
  
  deriving instance GHC.Classes.Eq a_515 => GHC.Classes.Eq (InferredParameters a_515)
  
  deriving instance GHC.Classes.Ord a_516 => GHC.Classes.Ord (InferredParameters a_516)
  
  deriving instance GHC.Show.Show a_517 => GHC.Show.Show (InferredParameters a_517)
  
  instance AST.Unmarshal.Unmarshal InferredParameters
  
  instance Data.Foldable.Foldable InferredParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InferredParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InferredParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InstanceofExpression a = InstanceofExpression
    { ann :: a,
      left :: (AST.Parse.Err (Expression a)),
      right :: (AST.Parse.Err (Type a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_518.
        AST.Traversable1.Class.Traversable1 a_518
      )
  
  instance AST.Unmarshal.SymbolMatching InstanceofExpression where
    matchedSymbols _ = [129]
    showFailure _ node_519 =
      "expected "
        GHC.Base.<> ( "instanceof_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_519 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_519) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_520 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_521 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_522 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_523 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_520
          c1_521 = TreeSitter.Node.nodeStartPoint node_519
        TreeSitter.Node.TSPoint
          r2_522
          c2_523 = TreeSitter.Node.nodeEndPoint node_519
  
  deriving instance GHC.Classes.Eq a_524 => GHC.Classes.Eq (InstanceofExpression a_524)
  
  deriving instance GHC.Classes.Ord a_525 => GHC.Classes.Ord (InstanceofExpression a_525)
  
  deriving instance GHC.Show.Show a_526 => GHC.Show.Show (InstanceofExpression a_526)
  
  instance AST.Unmarshal.Unmarshal InstanceofExpression
  
  instance Data.Foldable.Foldable InstanceofExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InstanceofExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InstanceofExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IntegralType a = IntegralType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_527.
        AST.Traversable1.Class.Traversable1 a_527
      )
  
  instance AST.Unmarshal.SymbolMatching IntegralType where
    matchedSymbols _ = [231]
    showFailure _ node_528 =
      "expected "
        GHC.Base.<> ( "integral_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_528 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_528) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_529 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_530 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_531 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_532 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_529
          c1_530 = TreeSitter.Node.nodeStartPoint node_528
        TreeSitter.Node.TSPoint
          r2_531
          c2_532 = TreeSitter.Node.nodeEndPoint node_528
  
  deriving instance GHC.Classes.Eq a_533 => GHC.Classes.Eq (IntegralType a_533)
  
  deriving instance GHC.Classes.Ord a_534 => GHC.Classes.Ord (IntegralType a_534)
  
  deriving instance GHC.Show.Show a_535 => GHC.Show.Show (IntegralType a_535)
  
  instance AST.Unmarshal.Unmarshal IntegralType
  
  instance Data.Foldable.Foldable IntegralType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IntegralType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IntegralType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InterfaceBody a = InterfaceBody
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((AnnotationTypeDeclaration GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: ConstantDeclaration GHC.Generics.:+: EnumDeclaration GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: MethodDeclaration) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_536.
        AST.Traversable1.Class.Traversable1 a_536
      )
  
  instance AST.Unmarshal.SymbolMatching InterfaceBody where
    matchedSymbols _ = [219]
    showFailure _ node_537 =
      "expected "
        GHC.Base.<> ( "interface_body"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_537 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_537) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_538 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_539 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_540 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_541 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_538
          c1_539 = TreeSitter.Node.nodeStartPoint node_537
        TreeSitter.Node.TSPoint
          r2_540
          c2_541 = TreeSitter.Node.nodeEndPoint node_537
  
  deriving instance GHC.Classes.Eq a_542 => GHC.Classes.Eq (InterfaceBody a_542)
  
  deriving instance GHC.Classes.Ord a_543 => GHC.Classes.Ord (InterfaceBody a_543)
  
  deriving instance GHC.Show.Show a_544 => GHC.Show.Show (InterfaceBody a_544)
  
  instance AST.Unmarshal.Unmarshal InterfaceBody
  
  instance Data.Foldable.Foldable InterfaceBody where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InterfaceBody where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InterfaceBody where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InterfaceDeclaration a = InterfaceDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (InterfaceBody a)),
      name :: (AST.Parse.Err (Identifier a)),
      typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
      extraChildren :: ([AST.Parse.Err ((ExtendsInterfaces GHC.Generics.:+: Modifiers) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_545.
        AST.Traversable1.Class.Traversable1 a_545
      )
  
  instance AST.Unmarshal.SymbolMatching InterfaceDeclaration where
    matchedSymbols _ = [217]
    showFailure _ node_546 =
      "expected "
        GHC.Base.<> ( "interface_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_546 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_546) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_547 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_548 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_549 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_550 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_547
          c1_548 = TreeSitter.Node.nodeStartPoint node_546
        TreeSitter.Node.TSPoint
          r2_549
          c2_550 = TreeSitter.Node.nodeEndPoint node_546
  
  deriving instance GHC.Classes.Eq a_551 => GHC.Classes.Eq (InterfaceDeclaration a_551)
  
  deriving instance GHC.Classes.Ord a_552 => GHC.Classes.Ord (InterfaceDeclaration a_552)
  
  deriving instance GHC.Show.Show a_553 => GHC.Show.Show (InterfaceDeclaration a_553)
  
  instance AST.Unmarshal.Unmarshal InterfaceDeclaration
  
  instance Data.Foldable.Foldable InterfaceDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InterfaceDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InterfaceDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InterfaceTypeList a = InterfaceTypeList
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_554.
        AST.Traversable1.Class.Traversable1 a_554
      )
  
  instance AST.Unmarshal.SymbolMatching InterfaceTypeList where
    matchedSymbols _ = [204]
    showFailure _ node_555 =
      "expected "
        GHC.Base.<> ( "interface_type_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_555 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_555) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_556 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_557 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_558 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_559 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_556
          c1_557 = TreeSitter.Node.nodeStartPoint node_555
        TreeSitter.Node.TSPoint
          r2_558
          c2_559 = TreeSitter.Node.nodeEndPoint node_555
  
  deriving instance GHC.Classes.Eq a_560 => GHC.Classes.Eq (InterfaceTypeList a_560)
  
  deriving instance GHC.Classes.Ord a_561 => GHC.Classes.Ord (InterfaceTypeList a_561)
  
  deriving instance GHC.Show.Show a_562 => GHC.Show.Show (InterfaceTypeList a_562)
  
  instance AST.Unmarshal.Unmarshal InterfaceTypeList
  
  instance Data.Foldable.Foldable InterfaceTypeList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InterfaceTypeList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InterfaceTypeList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LabeledStatement a = LabeledStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Statement GHC.Generics.:+: Identifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_563.
        AST.Traversable1.Class.Traversable1 a_563
      )
  
  instance AST.Unmarshal.SymbolMatching LabeledStatement where
    matchedSymbols _ = [154]
    showFailure _ node_564 =
      "expected "
        GHC.Base.<> ( "labeled_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_564 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_564) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_565 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_566 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_567 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_568 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_565
          c1_566 = TreeSitter.Node.nodeStartPoint node_564
        TreeSitter.Node.TSPoint
          r2_567
          c2_568 = TreeSitter.Node.nodeEndPoint node_564
  
  deriving instance GHC.Classes.Eq a_569 => GHC.Classes.Eq (LabeledStatement a_569)
  
  deriving instance GHC.Classes.Ord a_570 => GHC.Classes.Ord (LabeledStatement a_570)
  
  deriving instance GHC.Show.Show a_571 => GHC.Show.Show (LabeledStatement a_571)
  
  instance AST.Unmarshal.Unmarshal LabeledStatement
  
  instance Data.Foldable.Foldable LabeledStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LabeledStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LabeledStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LambdaExpression a = LambdaExpression
    { ann :: a,
      body :: (AST.Parse.Err ((Expression GHC.Generics.:+: Block) a)),
      parameters :: (AST.Parse.Err ((FormalParameters GHC.Generics.:+: Identifier GHC.Generics.:+: InferredParameters) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_572.
        AST.Traversable1.Class.Traversable1 a_572
      )
  
  instance AST.Unmarshal.SymbolMatching LambdaExpression where
    matchedSymbols _ = [130]
    showFailure _ node_573 =
      "expected "
        GHC.Base.<> ( "lambda_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_573 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_573) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_574 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_575 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_576 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_577 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_574
          c1_575 = TreeSitter.Node.nodeStartPoint node_573
        TreeSitter.Node.TSPoint
          r2_576
          c2_577 = TreeSitter.Node.nodeEndPoint node_573
  
  deriving instance GHC.Classes.Eq a_578 => GHC.Classes.Eq (LambdaExpression a_578)
  
  deriving instance GHC.Classes.Ord a_579 => GHC.Classes.Ord (LambdaExpression a_579)
  
  deriving instance GHC.Show.Show a_580 => GHC.Show.Show (LambdaExpression a_580)
  
  instance AST.Unmarshal.Unmarshal LambdaExpression
  
  instance Data.Foldable.Foldable LambdaExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LambdaExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LambdaExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LocalVariableDeclaration a = LocalVariableDeclaration
    { ann :: a,
      declarator :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableDeclarator a))),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Modifiers a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_581.
        AST.Traversable1.Class.Traversable1 a_581
      )
  
  instance AST.Unmarshal.SymbolMatching LocalVariableDeclaration where
    matchedSymbols _ = [241]
    showFailure _ node_582 =
      "expected "
        GHC.Base.<> ( "local_variable_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_582 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_582) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_583 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_584 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_585 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_586 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_583
          c1_584 = TreeSitter.Node.nodeStartPoint node_582
        TreeSitter.Node.TSPoint
          r2_585
          c2_586 = TreeSitter.Node.nodeEndPoint node_582
  
  deriving instance GHC.Classes.Eq a_587 => GHC.Classes.Eq (LocalVariableDeclaration a_587)
  
  deriving instance GHC.Classes.Ord a_588 => GHC.Classes.Ord (LocalVariableDeclaration a_588)
  
  deriving instance GHC.Show.Show a_589 => GHC.Show.Show (LocalVariableDeclaration a_589)
  
  instance AST.Unmarshal.Unmarshal LocalVariableDeclaration
  
  instance Data.Foldable.Foldable LocalVariableDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LocalVariableDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LocalVariableDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LocalVariableDeclarationStatement a = LocalVariableDeclarationStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (LocalVariableDeclaration a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_590.
        AST.Traversable1.Class.Traversable1 a_590
      )
  
  instance AST.Unmarshal.SymbolMatching LocalVariableDeclarationStatement where
    matchedSymbols _ = [240]
    showFailure _ node_591 =
      "expected "
        GHC.Base.<> ( "local_variable_declaration_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_591 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_591) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_592 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_593 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_594 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_595 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_592
          c1_593 = TreeSitter.Node.nodeStartPoint node_591
        TreeSitter.Node.TSPoint
          r2_594
          c2_595 = TreeSitter.Node.nodeEndPoint node_591
  
  deriving instance GHC.Classes.Eq a_596 => GHC.Classes.Eq (LocalVariableDeclarationStatement a_596)
  
  deriving instance GHC.Classes.Ord a_597 => GHC.Classes.Ord (LocalVariableDeclarationStatement a_597)
  
  deriving instance GHC.Show.Show a_598 => GHC.Show.Show (LocalVariableDeclarationStatement a_598)
  
  instance AST.Unmarshal.Unmarshal LocalVariableDeclarationStatement
  
  instance Data.Foldable.Foldable LocalVariableDeclarationStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LocalVariableDeclarationStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LocalVariableDeclarationStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MarkerAnnotation a = MarkerAnnotation
    { ann :: a,
      name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: ScopedIdentifier) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_599.
        AST.Traversable1.Class.Traversable1 a_599
      )
  
  instance AST.Unmarshal.SymbolMatching MarkerAnnotation where
    matchedSymbols _ = [179]
    showFailure _ node_600 =
      "expected "
        GHC.Base.<> ( "marker_annotation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_600 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_600) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_601 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_602 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_603 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_604 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_601
          c1_602 = TreeSitter.Node.nodeStartPoint node_600
        TreeSitter.Node.TSPoint
          r2_603
          c2_604 = TreeSitter.Node.nodeEndPoint node_600
  
  deriving instance GHC.Classes.Eq a_605 => GHC.Classes.Eq (MarkerAnnotation a_605)
  
  deriving instance GHC.Classes.Ord a_606 => GHC.Classes.Ord (MarkerAnnotation a_606)
  
  deriving instance GHC.Show.Show a_607 => GHC.Show.Show (MarkerAnnotation a_607)
  
  instance AST.Unmarshal.Unmarshal MarkerAnnotation
  
  instance Data.Foldable.Foldable MarkerAnnotation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MarkerAnnotation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MarkerAnnotation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodDeclaration a = MethodDeclaration
    { ann :: a,
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (Block a))),
      name :: (AST.Parse.Err (Identifier a)),
      parameters :: (AST.Parse.Err (FormalParameters a)),
      typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
      type' :: (AST.Parse.Err (UnannotatedType a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: ([AST.Parse.Err ((Annotation GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: Modifiers GHC.Generics.:+: Throws) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_608.
        AST.Traversable1.Class.Traversable1 a_608
      )
  
  instance AST.Unmarshal.SymbolMatching MethodDeclaration where
    matchedSymbols _ = [242]
    showFailure _ node_609 =
      "expected "
        GHC.Base.<> ( "method_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_609 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_609) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_610 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_611 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_612 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_613 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_610
          c1_611 = TreeSitter.Node.nodeStartPoint node_609
        TreeSitter.Node.TSPoint
          r2_612
          c2_613 = TreeSitter.Node.nodeEndPoint node_609
  
  deriving instance GHC.Classes.Eq a_614 => GHC.Classes.Eq (MethodDeclaration a_614)
  
  deriving instance GHC.Classes.Ord a_615 => GHC.Classes.Ord (MethodDeclaration a_615)
  
  deriving instance GHC.Show.Show a_616 => GHC.Show.Show (MethodDeclaration a_616)
  
  instance AST.Unmarshal.Unmarshal MethodDeclaration
  
  instance Data.Foldable.Foldable MethodDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodInvocation a = MethodInvocation
    { ann :: a,
      arguments :: (AST.Parse.Err (ArgumentList a)),
      name :: (AST.Parse.Err (Identifier a)),
      typeArguments :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeArguments a))),
      object :: (GHC.Maybe.Maybe (AST.Parse.Err ((Primary GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier GHC.Generics.:+: Super) a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Super a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_617.
        AST.Traversable1.Class.Traversable1 a_617
      )
  
  instance AST.Unmarshal.SymbolMatching MethodInvocation where
    matchedSymbols _ = [144]
    showFailure _ node_618 =
      "expected "
        GHC.Base.<> ( "method_invocation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_618 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_618) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_619 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_620 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_621 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_622 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_619
          c1_620 = TreeSitter.Node.nodeStartPoint node_618
        TreeSitter.Node.TSPoint
          r2_621
          c2_622 = TreeSitter.Node.nodeEndPoint node_618
  
  deriving instance GHC.Classes.Eq a_623 => GHC.Classes.Eq (MethodInvocation a_623)
  
  deriving instance GHC.Classes.Ord a_624 => GHC.Classes.Ord (MethodInvocation a_624)
  
  deriving instance GHC.Show.Show a_625 => GHC.Show.Show (MethodInvocation a_625)
  
  instance AST.Unmarshal.Unmarshal MethodInvocation
  
  instance Data.Foldable.Foldable MethodInvocation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodInvocation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodInvocation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodReference a = MethodReference
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Primary GHC.Generics.:+: Type GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier GHC.Generics.:+: Super GHC.Generics.:+: TypeArguments) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_626.
        AST.Traversable1.Class.Traversable1 a_626
      )
  
  instance AST.Unmarshal.SymbolMatching MethodReference where
    matchedSymbols _ = [146]
    showFailure _ node_627 =
      "expected "
        GHC.Base.<> ( "method_reference"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_627 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_627) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_628 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_629 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_630 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_631 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_628
          c1_629 = TreeSitter.Node.nodeStartPoint node_627
        TreeSitter.Node.TSPoint
          r2_630
          c2_631 = TreeSitter.Node.nodeEndPoint node_627
  
  deriving instance GHC.Classes.Eq a_632 => GHC.Classes.Eq (MethodReference a_632)
  
  deriving instance GHC.Classes.Ord a_633 => GHC.Classes.Ord (MethodReference a_633)
  
  deriving instance GHC.Show.Show a_634 => GHC.Show.Show (MethodReference a_634)
  
  instance AST.Unmarshal.Unmarshal MethodReference
  
  instance Data.Foldable.Foldable MethodReference where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodReference where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodReference where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Modifiers a = Modifiers
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Annotation GHC.Generics.:+: MarkerAnnotation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_635.
        AST.Traversable1.Class.Traversable1 a_635
      )
  
  instance AST.Unmarshal.SymbolMatching Modifiers where
    matchedSymbols _ = [198]
    showFailure _ node_636 =
      "expected "
        GHC.Base.<> ( "modifiers"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_636 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_636) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_637 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_638 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_639 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_640 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_637
          c1_638 = TreeSitter.Node.nodeStartPoint node_636
        TreeSitter.Node.TSPoint
          r2_639
          c2_640 = TreeSitter.Node.nodeEndPoint node_636
  
  deriving instance GHC.Classes.Eq a_641 => GHC.Classes.Eq (Modifiers a_641)
  
  deriving instance GHC.Classes.Ord a_642 => GHC.Classes.Ord (Modifiers a_642)
  
  deriving instance GHC.Show.Show a_643 => GHC.Show.Show (Modifiers a_643)
  
  instance AST.Unmarshal.Unmarshal Modifiers
  
  instance Data.Foldable.Foldable Modifiers where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Modifiers where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Modifiers where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleDeclaration a = ModuleDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: Identifier GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: ModuleDirective GHC.Generics.:+: ScopedIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_644.
        AST.Traversable1.Class.Traversable1 a_644
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleDeclaration where
    matchedSymbols _ = [186]
    showFailure _ node_645 =
      "expected "
        GHC.Base.<> ( "module_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_645 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_645) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_646 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_647 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_648 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_649 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_646
          c1_647 = TreeSitter.Node.nodeStartPoint node_645
        TreeSitter.Node.TSPoint
          r2_648
          c2_649 = TreeSitter.Node.nodeEndPoint node_645
  
  deriving instance GHC.Classes.Eq a_650 => GHC.Classes.Eq (ModuleDeclaration a_650)
  
  deriving instance GHC.Classes.Ord a_651 => GHC.Classes.Ord (ModuleDeclaration a_651)
  
  deriving instance GHC.Show.Show a_652 => GHC.Show.Show (ModuleDeclaration a_652)
  
  instance AST.Unmarshal.Unmarshal ModuleDeclaration
  
  instance Data.Foldable.Foldable ModuleDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleDirective a = ModuleDirective
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: ModuleName GHC.Generics.:+: RequiresModifier GHC.Generics.:+: ScopedIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_653.
        AST.Traversable1.Class.Traversable1 a_653
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleDirective where
    matchedSymbols _ = [187]
    showFailure _ node_654 =
      "expected "
        GHC.Base.<> ( "module_directive"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_654 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_654) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_655 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_656 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_657 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_658 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_655
          c1_656 = TreeSitter.Node.nodeStartPoint node_654
        TreeSitter.Node.TSPoint
          r2_657
          c2_658 = TreeSitter.Node.nodeEndPoint node_654
  
  deriving instance GHC.Classes.Eq a_659 => GHC.Classes.Eq (ModuleDirective a_659)
  
  deriving instance GHC.Classes.Ord a_660 => GHC.Classes.Ord (ModuleDirective a_660)
  
  deriving instance GHC.Show.Show a_661 => GHC.Show.Show (ModuleDirective a_661)
  
  instance AST.Unmarshal.Unmarshal ModuleDirective
  
  instance Data.Foldable.Foldable ModuleDirective where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ModuleDirective where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ModuleDirective where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ModuleName a = ModuleName
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: ModuleName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_662.
        AST.Traversable1.Class.Traversable1 a_662
      )
  
  instance AST.Unmarshal.SymbolMatching ModuleName where
    matchedSymbols _ = [189]
    showFailure _ node_663 =
      "expected "
        GHC.Base.<> ( "module_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_663 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_663) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_664 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_665 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_666 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_667 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_664
          c1_665 = TreeSitter.Node.nodeStartPoint node_663
        TreeSitter.Node.TSPoint
          r2_666
          c2_667 = TreeSitter.Node.nodeEndPoint node_663
  
  deriving instance GHC.Classes.Eq a_668 => GHC.Classes.Eq (ModuleName a_668)
  
  deriving instance GHC.Classes.Ord a_669 => GHC.Classes.Ord (ModuleName a_669)
  
  deriving instance GHC.Show.Show a_670 => GHC.Show.Show (ModuleName a_670)
  
  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 ObjectCreationExpression a = ObjectCreationExpression
    { ann :: a,
      arguments :: (AST.Parse.Err (ArgumentList a)),
      typeArguments :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeArguments a))),
      type' :: (AST.Parse.Err (SimpleType a)),
      extraChildren :: ([AST.Parse.Err ((Primary GHC.Generics.:+: ClassBody GHC.Generics.:+: Identifier GHC.Generics.:+: ScopedIdentifier) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_671.
        AST.Traversable1.Class.Traversable1 a_671
      )
  
  instance AST.Unmarshal.SymbolMatching ObjectCreationExpression where
    matchedSymbols _ = [140]
    showFailure _ node_672 =
      "expected "
        GHC.Base.<> ( "object_creation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_672 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_672) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_673 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_674 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_675 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_676 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_673
          c1_674 = TreeSitter.Node.nodeStartPoint node_672
        TreeSitter.Node.TSPoint
          r2_675
          c2_676 = TreeSitter.Node.nodeEndPoint node_672
  
  deriving instance GHC.Classes.Eq a_677 => GHC.Classes.Eq (ObjectCreationExpression a_677)
  
  deriving instance GHC.Classes.Ord a_678 => GHC.Classes.Ord (ObjectCreationExpression a_678)
  
  deriving instance GHC.Show.Show a_679 => GHC.Show.Show (ObjectCreationExpression a_679)
  
  instance AST.Unmarshal.Unmarshal ObjectCreationExpression
  
  instance Data.Foldable.Foldable ObjectCreationExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ObjectCreationExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ObjectCreationExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PackageDeclaration a = PackageDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: Identifier GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: ScopedIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_680.
        AST.Traversable1.Class.Traversable1 a_680
      )
  
  instance AST.Unmarshal.SymbolMatching PackageDeclaration where
    matchedSymbols _ = [190]
    showFailure _ node_681 =
      "expected "
        GHC.Base.<> ( "package_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_681 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_681) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_682 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_683 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_684 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_685 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_682
          c1_683 = TreeSitter.Node.nodeStartPoint node_681
        TreeSitter.Node.TSPoint
          r2_684
          c2_685 = TreeSitter.Node.nodeEndPoint node_681
  
  deriving instance GHC.Classes.Eq a_686 => GHC.Classes.Eq (PackageDeclaration a_686)
  
  deriving instance GHC.Classes.Ord a_687 => GHC.Classes.Ord (PackageDeclaration a_687)
  
  deriving instance GHC.Show.Show a_688 => GHC.Show.Show (PackageDeclaration a_688)
  
  instance AST.Unmarshal.Unmarshal PackageDeclaration
  
  instance Data.Foldable.Foldable PackageDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PackageDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PackageDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ParenthesizedExpression a = ParenthesizedExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_689.
        AST.Traversable1.Class.Traversable1 a_689
      )
  
  instance AST.Unmarshal.SymbolMatching ParenthesizedExpression where
    matchedSymbols _ = [138]
    showFailure _ node_690 =
      "expected "
        GHC.Base.<> ( "parenthesized_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_690 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_690) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_691 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_692 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_693 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_694 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_691
          c1_692 = TreeSitter.Node.nodeStartPoint node_690
        TreeSitter.Node.TSPoint
          r2_693
          c2_694 = TreeSitter.Node.nodeEndPoint node_690
  
  deriving instance GHC.Classes.Eq a_695 => GHC.Classes.Eq (ParenthesizedExpression a_695)
  
  deriving instance GHC.Classes.Ord a_696 => GHC.Classes.Ord (ParenthesizedExpression a_696)
  
  deriving instance GHC.Show.Show a_697 => GHC.Show.Show (ParenthesizedExpression a_697)
  
  instance AST.Unmarshal.Unmarshal ParenthesizedExpression
  
  instance Data.Foldable.Foldable ParenthesizedExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ParenthesizedExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ParenthesizedExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Program a = Program
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_698.
        AST.Traversable1.Class.Traversable1 a_698
      )
  
  instance AST.Unmarshal.SymbolMatching Program where
    matchedSymbols _ = [123]
    showFailure _ node_699 =
      "expected "
        GHC.Base.<> ( "program"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_699 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_699) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_700 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_701 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_702 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_703 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_700
          c1_701 = TreeSitter.Node.nodeStartPoint node_699
        TreeSitter.Node.TSPoint
          r2_702
          c2_703 = TreeSitter.Node.nodeEndPoint node_699
  
  deriving instance GHC.Classes.Eq a_704 => GHC.Classes.Eq (Program a_704)
  
  deriving instance GHC.Classes.Ord a_705 => GHC.Classes.Ord (Program a_705)
  
  deriving instance GHC.Show.Show a_706 => GHC.Show.Show (Program a_706)
  
  instance AST.Unmarshal.Unmarshal Program
  
  instance Data.Foldable.Foldable Program where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Program where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Program where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ReceiverParameter a = ReceiverParameter
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((UnannotatedType GHC.Generics.:+: Annotation GHC.Generics.:+: Identifier GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: This) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_707.
        AST.Traversable1.Class.Traversable1 a_707
      )
  
  instance AST.Unmarshal.SymbolMatching ReceiverParameter where
    matchedSymbols _ = [237]
    showFailure _ node_708 =
      "expected "
        GHC.Base.<> ( "receiver_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_708 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_708) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_709 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_710 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_711 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_712 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_709
          c1_710 = TreeSitter.Node.nodeStartPoint node_708
        TreeSitter.Node.TSPoint
          r2_711
          c2_712 = TreeSitter.Node.nodeEndPoint node_708
  
  deriving instance GHC.Classes.Eq a_713 => GHC.Classes.Eq (ReceiverParameter a_713)
  
  deriving instance GHC.Classes.Ord a_714 => GHC.Classes.Ord (ReceiverParameter a_714)
  
  deriving instance GHC.Show.Show a_715 => GHC.Show.Show (ReceiverParameter a_715)
  
  instance AST.Unmarshal.Unmarshal ReceiverParameter
  
  instance Data.Foldable.Foldable ReceiverParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ReceiverParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ReceiverParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RequiresModifier a = RequiresModifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_716.
        AST.Traversable1.Class.Traversable1 a_716
      )
  
  instance AST.Unmarshal.SymbolMatching RequiresModifier where
    matchedSymbols _ = [188]
    showFailure _ node_717 =
      "expected "
        GHC.Base.<> ( "requires_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_717 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_717) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_718 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_719 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_720 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_721 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_718
          c1_719 = TreeSitter.Node.nodeStartPoint node_717
        TreeSitter.Node.TSPoint
          r2_720
          c2_721 = TreeSitter.Node.nodeEndPoint node_717
  
  deriving instance GHC.Classes.Eq a_722 => GHC.Classes.Eq (RequiresModifier a_722)
  
  deriving instance GHC.Classes.Ord a_723 => GHC.Classes.Ord (RequiresModifier a_723)
  
  deriving instance GHC.Show.Show a_724 => GHC.Show.Show (RequiresModifier a_724)
  
  instance AST.Unmarshal.Unmarshal RequiresModifier
  
  instance Data.Foldable.Foldable RequiresModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RequiresModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RequiresModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Resource a = Resource
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a))),
      type' :: (GHC.Maybe.Maybe (AST.Parse.Err (UnannotatedType a))),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((FieldAccess GHC.Generics.:+: Identifier GHC.Generics.:+: Modifiers GHC.Generics.:+: ScopedIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_725.
        AST.Traversable1.Class.Traversable1 a_725
      )
  
  instance AST.Unmarshal.SymbolMatching Resource where
    matchedSymbols _ = [172]
    showFailure _ node_726 =
      "expected "
        GHC.Base.<> ( "resource"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_726 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_726) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_727 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_728 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_729 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_730 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_727
          c1_728 = TreeSitter.Node.nodeStartPoint node_726
        TreeSitter.Node.TSPoint
          r2_729
          c2_730 = TreeSitter.Node.nodeEndPoint node_726
  
  deriving instance GHC.Classes.Eq a_731 => GHC.Classes.Eq (Resource a_731)
  
  deriving instance GHC.Classes.Ord a_732 => GHC.Classes.Ord (Resource a_732)
  
  deriving instance GHC.Show.Show a_733 => GHC.Show.Show (Resource a_733)
  
  instance AST.Unmarshal.Unmarshal Resource
  
  instance Data.Foldable.Foldable Resource where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Resource where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Resource where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ResourceSpecification a = ResourceSpecification
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Resource a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_734.
        AST.Traversable1.Class.Traversable1 a_734
      )
  
  instance AST.Unmarshal.SymbolMatching ResourceSpecification where
    matchedSymbols _ = [171]
    showFailure _ node_735 =
      "expected "
        GHC.Base.<> ( "resource_specification"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_735 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_735) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_736 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_737 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_738 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_739 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_736
          c1_737 = TreeSitter.Node.nodeStartPoint node_735
        TreeSitter.Node.TSPoint
          r2_738
          c2_739 = TreeSitter.Node.nodeEndPoint node_735
  
  deriving instance GHC.Classes.Eq a_740 => GHC.Classes.Eq (ResourceSpecification a_740)
  
  deriving instance GHC.Classes.Ord a_741 => GHC.Classes.Ord (ResourceSpecification a_741)
  
  deriving instance GHC.Show.Show a_742 => GHC.Show.Show (ResourceSpecification a_742)
  
  instance AST.Unmarshal.Unmarshal ResourceSpecification
  
  instance Data.Foldable.Foldable ResourceSpecification where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ResourceSpecification where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ResourceSpecification where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ReturnStatement a = ReturnStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_743.
        AST.Traversable1.Class.Traversable1 a_743
      )
  
  instance AST.Unmarshal.SymbolMatching ReturnStatement where
    matchedSymbols _ = [162]
    showFailure _ node_744 =
      "expected "
        GHC.Base.<> ( "return_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_744 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_744) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_745 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_746 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_747 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_748 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_745
          c1_746 = TreeSitter.Node.nodeStartPoint node_744
        TreeSitter.Node.TSPoint
          r2_747
          c2_748 = TreeSitter.Node.nodeEndPoint node_744
  
  deriving instance GHC.Classes.Eq a_749 => GHC.Classes.Eq (ReturnStatement a_749)
  
  deriving instance GHC.Classes.Ord a_750 => GHC.Classes.Ord (ReturnStatement a_750)
  
  deriving instance GHC.Show.Show a_751 => GHC.Show.Show (ReturnStatement a_751)
  
  instance AST.Unmarshal.Unmarshal ReturnStatement
  
  instance Data.Foldable.Foldable ReturnStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ReturnStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ReturnStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ScopedIdentifier a = ScopedIdentifier
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: ScopedIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_752.
        AST.Traversable1.Class.Traversable1 a_752
      )
  
  instance AST.Unmarshal.SymbolMatching ScopedIdentifier where
    matchedSymbols _ = [211]
    showFailure _ node_753 =
      "expected "
        GHC.Base.<> ( "scoped_identifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_753 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_753) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_754 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_755 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_756 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_757 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_754
          c1_755 = TreeSitter.Node.nodeStartPoint node_753
        TreeSitter.Node.TSPoint
          r2_756
          c2_757 = TreeSitter.Node.nodeEndPoint node_753
  
  deriving instance GHC.Classes.Eq a_758 => GHC.Classes.Eq (ScopedIdentifier a_758)
  
  deriving instance GHC.Classes.Ord a_759 => GHC.Classes.Ord (ScopedIdentifier a_759)
  
  deriving instance GHC.Show.Show a_760 => GHC.Show.Show (ScopedIdentifier a_760)
  
  instance AST.Unmarshal.Unmarshal ScopedIdentifier
  
  instance Data.Foldable.Foldable ScopedIdentifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ScopedIdentifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ScopedIdentifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ScopedTypeIdentifier a = ScopedTypeIdentifier
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: GenericType GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: ScopedTypeIdentifier GHC.Generics.:+: TypeIdentifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_761.
        AST.Traversable1.Class.Traversable1 a_761
      )
  
  instance AST.Unmarshal.SymbolMatching ScopedTypeIdentifier where
    matchedSymbols _ = [228]
    showFailure _ node_762 =
      "expected "
        GHC.Base.<> ( "scoped_type_identifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_762 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_762) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_763 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_764 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_765 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_766 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_763
          c1_764 = TreeSitter.Node.nodeStartPoint node_762
        TreeSitter.Node.TSPoint
          r2_765
          c2_766 = TreeSitter.Node.nodeEndPoint node_762
  
  deriving instance GHC.Classes.Eq a_767 => GHC.Classes.Eq (ScopedTypeIdentifier a_767)
  
  deriving instance GHC.Classes.Ord a_768 => GHC.Classes.Ord (ScopedTypeIdentifier a_768)
  
  deriving instance GHC.Show.Show a_769 => GHC.Show.Show (ScopedTypeIdentifier a_769)
  
  instance AST.Unmarshal.Unmarshal ScopedTypeIdentifier
  
  instance Data.Foldable.Foldable ScopedTypeIdentifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ScopedTypeIdentifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ScopedTypeIdentifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SpreadParameter a = SpreadParameter
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((UnannotatedType GHC.Generics.:+: Modifiers GHC.Generics.:+: VariableDeclarator) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_770.
        AST.Traversable1.Class.Traversable1 a_770
      )
  
  instance AST.Unmarshal.SymbolMatching SpreadParameter where
    matchedSymbols _ = [238]
    showFailure _ node_771 =
      "expected "
        GHC.Base.<> ( "spread_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_771 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_771) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_772 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_773 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_774 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_775 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_772
          c1_773 = TreeSitter.Node.nodeStartPoint node_771
        TreeSitter.Node.TSPoint
          r2_774
          c2_775 = TreeSitter.Node.nodeEndPoint node_771
  
  deriving instance GHC.Classes.Eq a_776 => GHC.Classes.Eq (SpreadParameter a_776)
  
  deriving instance GHC.Classes.Ord a_777 => GHC.Classes.Ord (SpreadParameter a_777)
  
  deriving instance GHC.Show.Show a_778 => GHC.Show.Show (SpreadParameter a_778)
  
  instance AST.Unmarshal.Unmarshal SpreadParameter
  
  instance Data.Foldable.Foldable SpreadParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SpreadParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SpreadParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data StaticInitializer a = StaticInitializer
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Block a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_779.
        AST.Traversable1.Class.Traversable1 a_779
      )
  
  instance AST.Unmarshal.SymbolMatching StaticInitializer where
    matchedSymbols _ = [206]
    showFailure _ node_780 =
      "expected "
        GHC.Base.<> ( "static_initializer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_780 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_780) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_781 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_782 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_783 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_784 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_781
          c1_782 = TreeSitter.Node.nodeStartPoint node_780
        TreeSitter.Node.TSPoint
          r2_783
          c2_784 = TreeSitter.Node.nodeEndPoint node_780
  
  deriving instance GHC.Classes.Eq a_785 => GHC.Classes.Eq (StaticInitializer a_785)
  
  deriving instance GHC.Classes.Ord a_786 => GHC.Classes.Ord (StaticInitializer a_786)
  
  deriving instance GHC.Show.Show a_787 => GHC.Show.Show (StaticInitializer a_787)
  
  instance AST.Unmarshal.Unmarshal StaticInitializer
  
  instance Data.Foldable.Foldable StaticInitializer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor StaticInitializer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable StaticInitializer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SuperInterfaces a = SuperInterfaces
    { ann :: a,
      extraChildren :: (AST.Parse.Err (InterfaceTypeList a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_788.
        AST.Traversable1.Class.Traversable1 a_788
      )
  
  instance AST.Unmarshal.SymbolMatching SuperInterfaces where
    matchedSymbols _ = [203]
    showFailure _ node_789 =
      "expected "
        GHC.Base.<> ( "super_interfaces"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_789 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_789) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_790 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_791 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_792 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_793 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_790
          c1_791 = TreeSitter.Node.nodeStartPoint node_789
        TreeSitter.Node.TSPoint
          r2_792
          c2_793 = TreeSitter.Node.nodeEndPoint node_789
  
  deriving instance GHC.Classes.Eq a_794 => GHC.Classes.Eq (SuperInterfaces a_794)
  
  deriving instance GHC.Classes.Ord a_795 => GHC.Classes.Ord (SuperInterfaces a_795)
  
  deriving instance GHC.Show.Show a_796 => GHC.Show.Show (SuperInterfaces a_796)
  
  instance AST.Unmarshal.Unmarshal SuperInterfaces
  
  instance Data.Foldable.Foldable SuperInterfaces where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SuperInterfaces where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SuperInterfaces where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Superclass a = Superclass {ann :: a, extraChildren :: (AST.Parse.Err (Type a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_797.
        AST.Traversable1.Class.Traversable1 a_797
      )
  
  instance AST.Unmarshal.SymbolMatching Superclass where
    matchedSymbols _ = [202]
    showFailure _ node_798 =
      "expected "
        GHC.Base.<> ( "superclass"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_798 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_798) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_799 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_800 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_801 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_802 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_799
          c1_800 = TreeSitter.Node.nodeStartPoint node_798
        TreeSitter.Node.TSPoint
          r2_801
          c2_802 = TreeSitter.Node.nodeEndPoint node_798
  
  deriving instance GHC.Classes.Eq a_803 => GHC.Classes.Eq (Superclass a_803)
  
  deriving instance GHC.Classes.Ord a_804 => GHC.Classes.Ord (Superclass a_804)
  
  deriving instance GHC.Show.Show a_805 => GHC.Show.Show (Superclass a_805)
  
  instance AST.Unmarshal.Unmarshal Superclass
  
  instance Data.Foldable.Foldable Superclass where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Superclass where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Superclass where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SwitchBlock a = SwitchBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: SwitchLabel) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_806.
        AST.Traversable1.Class.Traversable1 a_806
      )
  
  instance AST.Unmarshal.SymbolMatching SwitchBlock where
    matchedSymbols _ = [157]
    showFailure _ node_807 =
      "expected "
        GHC.Base.<> ( "switch_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_807 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_807) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_808 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_809 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_810 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_811 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_808
          c1_809 = TreeSitter.Node.nodeStartPoint node_807
        TreeSitter.Node.TSPoint
          r2_810
          c2_811 = TreeSitter.Node.nodeEndPoint node_807
  
  deriving instance GHC.Classes.Eq a_812 => GHC.Classes.Eq (SwitchBlock a_812)
  
  deriving instance GHC.Classes.Ord a_813 => GHC.Classes.Ord (SwitchBlock a_813)
  
  deriving instance GHC.Show.Show a_814 => GHC.Show.Show (SwitchBlock a_814)
  
  instance AST.Unmarshal.Unmarshal SwitchBlock
  
  instance Data.Foldable.Foldable SwitchBlock where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SwitchBlock where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SwitchBlock where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SwitchLabel a = SwitchLabel
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_815.
        AST.Traversable1.Class.Traversable1 a_815
      )
  
  instance AST.Unmarshal.SymbolMatching SwitchLabel where
    matchedSymbols _ = [158]
    showFailure _ node_816 =
      "expected "
        GHC.Base.<> ( "switch_label"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_816 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_816) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_817 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_818 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_819 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_820 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_817
          c1_818 = TreeSitter.Node.nodeStartPoint node_816
        TreeSitter.Node.TSPoint
          r2_819
          c2_820 = TreeSitter.Node.nodeEndPoint node_816
  
  deriving instance GHC.Classes.Eq a_821 => GHC.Classes.Eq (SwitchLabel a_821)
  
  deriving instance GHC.Classes.Ord a_822 => GHC.Classes.Ord (SwitchLabel a_822)
  
  deriving instance GHC.Show.Show a_823 => GHC.Show.Show (SwitchLabel a_823)
  
  instance AST.Unmarshal.Unmarshal SwitchLabel
  
  instance Data.Foldable.Foldable SwitchLabel where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SwitchLabel where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SwitchLabel where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SwitchStatement a = SwitchStatement
    { ann :: a,
      body :: (AST.Parse.Err (SwitchBlock a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_824.
        AST.Traversable1.Class.Traversable1 a_824
      )
  
  instance AST.Unmarshal.SymbolMatching SwitchStatement where
    matchedSymbols _ = [156]
    showFailure _ node_825 =
      "expected "
        GHC.Base.<> ( "switch_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_825 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_825) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_826 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_827 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_828 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_829 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_826
          c1_827 = TreeSitter.Node.nodeStartPoint node_825
        TreeSitter.Node.TSPoint
          r2_828
          c2_829 = TreeSitter.Node.nodeEndPoint node_825
  
  deriving instance GHC.Classes.Eq a_830 => GHC.Classes.Eq (SwitchStatement a_830)
  
  deriving instance GHC.Classes.Ord a_831 => GHC.Classes.Ord (SwitchStatement a_831)
  
  deriving instance GHC.Show.Show a_832 => GHC.Show.Show (SwitchStatement a_832)
  
  instance AST.Unmarshal.Unmarshal SwitchStatement
  
  instance Data.Foldable.Foldable SwitchStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SwitchStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SwitchStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SynchronizedStatement a = SynchronizedStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Block) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_833.
        AST.Traversable1.Class.Traversable1 a_833
      )
  
  instance AST.Unmarshal.SymbolMatching SynchronizedStatement where
    matchedSymbols _ = [163]
    showFailure _ node_834 =
      "expected "
        GHC.Base.<> ( "synchronized_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_834 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_834) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_835 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_836 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_837 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_838 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_835
          c1_836 = TreeSitter.Node.nodeStartPoint node_834
        TreeSitter.Node.TSPoint
          r2_837
          c2_838 = TreeSitter.Node.nodeEndPoint node_834
  
  deriving instance GHC.Classes.Eq a_839 => GHC.Classes.Eq (SynchronizedStatement a_839)
  
  deriving instance GHC.Classes.Ord a_840 => GHC.Classes.Ord (SynchronizedStatement a_840)
  
  deriving instance GHC.Show.Show a_841 => GHC.Show.Show (SynchronizedStatement a_841)
  
  instance AST.Unmarshal.Unmarshal SynchronizedStatement
  
  instance Data.Foldable.Foldable SynchronizedStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SynchronizedStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SynchronizedStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TernaryExpression a = TernaryExpression
    { ann :: a,
      alternative :: (AST.Parse.Err (Expression a)),
      consequence :: (AST.Parse.Err (Expression a)),
      condition :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_842.
        AST.Traversable1.Class.Traversable1 a_842
      )
  
  instance AST.Unmarshal.SymbolMatching TernaryExpression where
    matchedSymbols _ = [132]
    showFailure _ node_843 =
      "expected "
        GHC.Base.<> ( "ternary_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_843 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_843) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_844 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_845 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_846 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_847 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_844
          c1_845 = TreeSitter.Node.nodeStartPoint node_843
        TreeSitter.Node.TSPoint
          r2_846
          c2_847 = TreeSitter.Node.nodeEndPoint node_843
  
  deriving instance GHC.Classes.Eq a_848 => GHC.Classes.Eq (TernaryExpression a_848)
  
  deriving instance GHC.Classes.Ord a_849 => GHC.Classes.Ord (TernaryExpression a_849)
  
  deriving instance GHC.Show.Show a_850 => GHC.Show.Show (TernaryExpression a_850)
  
  instance AST.Unmarshal.Unmarshal TernaryExpression
  
  instance Data.Foldable.Foldable TernaryExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TernaryExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TernaryExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ThrowStatement a = ThrowStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_851.
        AST.Traversable1.Class.Traversable1 a_851
      )
  
  instance AST.Unmarshal.SymbolMatching ThrowStatement where
    matchedSymbols _ = [164]
    showFailure _ node_852 =
      "expected "
        GHC.Base.<> ( "throw_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_852 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_852) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_853 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_854 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_855 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_856 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_853
          c1_854 = TreeSitter.Node.nodeStartPoint node_852
        TreeSitter.Node.TSPoint
          r2_855
          c2_856 = TreeSitter.Node.nodeEndPoint node_852
  
  deriving instance GHC.Classes.Eq a_857 => GHC.Classes.Eq (ThrowStatement a_857)
  
  deriving instance GHC.Classes.Ord a_858 => GHC.Classes.Ord (ThrowStatement a_858)
  
  deriving instance GHC.Show.Show a_859 => GHC.Show.Show (ThrowStatement a_859)
  
  instance AST.Unmarshal.Unmarshal ThrowStatement
  
  instance Data.Foldable.Foldable ThrowStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ThrowStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ThrowStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Throws a = Throws
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_860.
        AST.Traversable1.Class.Traversable1 a_860
      )
  
  instance AST.Unmarshal.SymbolMatching Throws where
    matchedSymbols _ = [239]
    showFailure _ node_861 =
      "expected "
        GHC.Base.<> ( "throws"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_861 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_861) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_862 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_863 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_864 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_865 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_862
          c1_863 = TreeSitter.Node.nodeStartPoint node_861
        TreeSitter.Node.TSPoint
          r2_864
          c2_865 = TreeSitter.Node.nodeEndPoint node_861
  
  deriving instance GHC.Classes.Eq a_866 => GHC.Classes.Eq (Throws a_866)
  
  deriving instance GHC.Classes.Ord a_867 => GHC.Classes.Ord (Throws a_867)
  
  deriving instance GHC.Show.Show a_868 => GHC.Show.Show (Throws a_868)
  
  instance AST.Unmarshal.Unmarshal Throws
  
  instance Data.Foldable.Foldable Throws where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Throws where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Throws where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TryStatement a = TryStatement
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((CatchClause GHC.Generics.:+: FinallyClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_869.
        AST.Traversable1.Class.Traversable1 a_869
      )
  
  instance AST.Unmarshal.SymbolMatching TryStatement where
    matchedSymbols _ = [165]
    showFailure _ node_870 =
      "expected "
        GHC.Base.<> ( "try_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_870 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_870) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_871 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_872 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_873 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_874 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_871
          c1_872 = TreeSitter.Node.nodeStartPoint node_870
        TreeSitter.Node.TSPoint
          r2_873
          c2_874 = TreeSitter.Node.nodeEndPoint node_870
  
  deriving instance GHC.Classes.Eq a_875 => GHC.Classes.Eq (TryStatement a_875)
  
  deriving instance GHC.Classes.Ord a_876 => GHC.Classes.Ord (TryStatement a_876)
  
  deriving instance GHC.Show.Show a_877 => GHC.Show.Show (TryStatement a_877)
  
  instance AST.Unmarshal.Unmarshal TryStatement
  
  instance Data.Foldable.Foldable TryStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TryStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TryStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TryWithResourcesStatement a = TryWithResourcesStatement
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      resources :: (AST.Parse.Err (ResourceSpecification a)),
      extraChildren :: ([AST.Parse.Err ((CatchClause GHC.Generics.:+: FinallyClause) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_878.
        AST.Traversable1.Class.Traversable1 a_878
      )
  
  instance AST.Unmarshal.SymbolMatching TryWithResourcesStatement where
    matchedSymbols _ = [170]
    showFailure _ node_879 =
      "expected "
        GHC.Base.<> ( "try_with_resources_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_879 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_879) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_880 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_881 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_882 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_883 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_880
          c1_881 = TreeSitter.Node.nodeStartPoint node_879
        TreeSitter.Node.TSPoint
          r2_882
          c2_883 = TreeSitter.Node.nodeEndPoint node_879
  
  deriving instance GHC.Classes.Eq a_884 => GHC.Classes.Eq (TryWithResourcesStatement a_884)
  
  deriving instance GHC.Classes.Ord a_885 => GHC.Classes.Ord (TryWithResourcesStatement a_885)
  
  deriving instance GHC.Show.Show a_886 => GHC.Show.Show (TryWithResourcesStatement a_886)
  
  instance AST.Unmarshal.Unmarshal TryWithResourcesStatement
  
  instance Data.Foldable.Foldable TryWithResourcesStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TryWithResourcesStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TryWithResourcesStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeArguments a = TypeArguments
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Type GHC.Generics.:+: Wildcard) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_887.
        AST.Traversable1.Class.Traversable1 a_887
      )
  
  instance AST.Unmarshal.SymbolMatching TypeArguments where
    matchedSymbols _ = [147]
    showFailure _ node_888 =
      "expected "
        GHC.Base.<> ( "type_arguments"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_888 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_888) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_889 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_890 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_891 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_892 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_889
          c1_890 = TreeSitter.Node.nodeStartPoint node_888
        TreeSitter.Node.TSPoint
          r2_891
          c2_892 = TreeSitter.Node.nodeEndPoint node_888
  
  deriving instance GHC.Classes.Eq a_893 => GHC.Classes.Eq (TypeArguments a_893)
  
  deriving instance GHC.Classes.Ord a_894 => GHC.Classes.Ord (TypeArguments a_894)
  
  deriving instance GHC.Show.Show a_895 => GHC.Show.Show (TypeArguments a_895)
  
  instance AST.Unmarshal.Unmarshal TypeArguments
  
  instance Data.Foldable.Foldable TypeArguments where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeArguments where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeArguments where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeBound a = TypeBound
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_896.
        AST.Traversable1.Class.Traversable1 a_896
      )
  
  instance AST.Unmarshal.SymbolMatching TypeBound where
    matchedSymbols _ = [201]
    showFailure _ node_897 =
      "expected "
        GHC.Base.<> ( "type_bound"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_897 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_897) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_898 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_899 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_900 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_901 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_898
          c1_899 = TreeSitter.Node.nodeStartPoint node_897
        TreeSitter.Node.TSPoint
          r2_900
          c2_901 = TreeSitter.Node.nodeEndPoint node_897
  
  deriving instance GHC.Classes.Eq a_902 => GHC.Classes.Eq (TypeBound a_902)
  
  deriving instance GHC.Classes.Ord a_903 => GHC.Classes.Ord (TypeBound a_903)
  
  deriving instance GHC.Show.Show a_904 => GHC.Show.Show (TypeBound a_904)
  
  instance AST.Unmarshal.Unmarshal TypeBound
  
  instance Data.Foldable.Foldable TypeBound where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeBound where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeBound where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeParameter a = TypeParameter
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Annotation GHC.Generics.:+: Identifier GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: TypeBound) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_905.
        AST.Traversable1.Class.Traversable1 a_905
      )
  
  instance AST.Unmarshal.SymbolMatching TypeParameter where
    matchedSymbols _ = [200]
    showFailure _ node_906 =
      "expected "
        GHC.Base.<> ( "type_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_906 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_906) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_907 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_908 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_909 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_910 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_907
          c1_908 = TreeSitter.Node.nodeStartPoint node_906
        TreeSitter.Node.TSPoint
          r2_909
          c2_910 = TreeSitter.Node.nodeEndPoint node_906
  
  deriving instance GHC.Classes.Eq a_911 => GHC.Classes.Eq (TypeParameter a_911)
  
  deriving instance GHC.Classes.Ord a_912 => GHC.Classes.Ord (TypeParameter a_912)
  
  deriving instance GHC.Show.Show a_913 => GHC.Show.Show (TypeParameter a_913)
  
  instance AST.Unmarshal.Unmarshal TypeParameter
  
  instance Data.Foldable.Foldable TypeParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypeParameters a = TypeParameters
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (TypeParameter a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_914.
        AST.Traversable1.Class.Traversable1 a_914
      )
  
  instance AST.Unmarshal.SymbolMatching TypeParameters where
    matchedSymbols _ = [199]
    showFailure _ node_915 =
      "expected "
        GHC.Base.<> ( "type_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_915 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_915) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_916 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_917 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_918 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_919 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_916
          c1_917 = TreeSitter.Node.nodeStartPoint node_915
        TreeSitter.Node.TSPoint
          r2_918
          c2_919 = TreeSitter.Node.nodeEndPoint node_915
  
  deriving instance GHC.Classes.Eq a_920 => GHC.Classes.Eq (TypeParameters a_920)
  
  deriving instance GHC.Classes.Ord a_921 => GHC.Classes.Ord (TypeParameters a_921)
  
  deriving instance GHC.Show.Show a_922 => GHC.Show.Show (TypeParameters a_922)
  
  instance AST.Unmarshal.Unmarshal TypeParameters
  
  instance Data.Foldable.Foldable TypeParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnaryExpression a = UnaryExpression
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousBang GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousTilde) a)),
      operand :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_923.
        AST.Traversable1.Class.Traversable1 a_923
      )
  
  instance AST.Unmarshal.SymbolMatching UnaryExpression where
    matchedSymbols _ = [133]
    showFailure _ node_924 =
      "expected "
        GHC.Base.<> ( "unary_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_924 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_924) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_925 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_926 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_927 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_928 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_925
          c1_926 = TreeSitter.Node.nodeStartPoint node_924
        TreeSitter.Node.TSPoint
          r2_927
          c2_928 = TreeSitter.Node.nodeEndPoint node_924
  
  deriving instance GHC.Classes.Eq a_929 => GHC.Classes.Eq (UnaryExpression a_929)
  
  deriving instance GHC.Classes.Ord a_930 => GHC.Classes.Ord (UnaryExpression a_930)
  
  deriving instance GHC.Show.Show a_931 => GHC.Show.Show (UnaryExpression a_931)
  
  instance AST.Unmarshal.Unmarshal UnaryExpression
  
  instance Data.Foldable.Foldable UnaryExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnaryExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnaryExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UpdateExpression a = UpdateExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_932.
        AST.Traversable1.Class.Traversable1 a_932
      )
  
  instance AST.Unmarshal.SymbolMatching UpdateExpression where
    matchedSymbols _ = [134]
    showFailure _ node_933 =
      "expected "
        GHC.Base.<> ( "update_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_933 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_933) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_934 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_935 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_936 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_937 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_934
          c1_935 = TreeSitter.Node.nodeStartPoint node_933
        TreeSitter.Node.TSPoint
          r2_936
          c2_937 = TreeSitter.Node.nodeEndPoint node_933
  
  deriving instance GHC.Classes.Eq a_938 => GHC.Classes.Eq (UpdateExpression a_938)
  
  deriving instance GHC.Classes.Ord a_939 => GHC.Classes.Ord (UpdateExpression a_939)
  
  deriving instance GHC.Show.Show a_940 => GHC.Show.Show (UpdateExpression a_940)
  
  instance AST.Unmarshal.Unmarshal UpdateExpression
  
  instance Data.Foldable.Foldable UpdateExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UpdateExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UpdateExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VariableDeclarator a = VariableDeclarator
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: ArrayInitializer) a))),
      name :: (AST.Parse.Err (Identifier a)),
      dimensions :: (GHC.Maybe.Maybe (AST.Parse.Err (Dimensions a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_941.
        AST.Traversable1.Class.Traversable1 a_941
      )
  
  instance AST.Unmarshal.SymbolMatching VariableDeclarator where
    matchedSymbols _ = [222]
    showFailure _ node_942 =
      "expected "
        GHC.Base.<> ( "variable_declarator"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_942 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_942) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_943 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_944 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_945 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_946 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_943
          c1_944 = TreeSitter.Node.nodeStartPoint node_942
        TreeSitter.Node.TSPoint
          r2_945
          c2_946 = TreeSitter.Node.nodeEndPoint node_942
  
  deriving instance GHC.Classes.Eq a_947 => GHC.Classes.Eq (VariableDeclarator a_947)
  
  deriving instance GHC.Classes.Ord a_948 => GHC.Classes.Ord (VariableDeclarator a_948)
  
  deriving instance GHC.Show.Show a_949 => GHC.Show.Show (VariableDeclarator a_949)
  
  instance AST.Unmarshal.Unmarshal VariableDeclarator
  
  instance Data.Foldable.Foldable VariableDeclarator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VariableDeclarator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VariableDeclarator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WhileStatement a = WhileStatement
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_950.
        AST.Traversable1.Class.Traversable1 a_950
      )
  
  instance AST.Unmarshal.SymbolMatching WhileStatement where
    matchedSymbols _ = [174]
    showFailure _ node_951 =
      "expected "
        GHC.Base.<> ( "while_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_951 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_951) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_952 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_953 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_954 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_955 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_952
          c1_953 = TreeSitter.Node.nodeStartPoint node_951
        TreeSitter.Node.TSPoint
          r2_954
          c2_955 = TreeSitter.Node.nodeEndPoint node_951
  
  deriving instance GHC.Classes.Eq a_956 => GHC.Classes.Eq (WhileStatement a_956)
  
  deriving instance GHC.Classes.Ord a_957 => GHC.Classes.Ord (WhileStatement a_957)
  
  deriving instance GHC.Show.Show a_958 => GHC.Show.Show (WhileStatement a_958)
  
  instance AST.Unmarshal.Unmarshal WhileStatement
  
  instance Data.Foldable.Foldable WhileStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor WhileStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable WhileStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Wildcard a = Wildcard
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Type GHC.Generics.:+: Annotation GHC.Generics.:+: MarkerAnnotation GHC.Generics.:+: Super) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_959.
        AST.Traversable1.Class.Traversable1 a_959
      )
  
  instance AST.Unmarshal.SymbolMatching Wildcard where
    matchedSymbols _ = [148]
    showFailure _ node_960 =
      "expected "
        GHC.Base.<> ( "wildcard"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_960 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_960) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_961 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_962 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_963 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_964 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_961
          c1_962 = TreeSitter.Node.nodeStartPoint node_960
        TreeSitter.Node.TSPoint
          r2_963
          c2_964 = TreeSitter.Node.nodeEndPoint node_960
  
  deriving instance GHC.Classes.Eq a_965 => GHC.Classes.Eq (Wildcard a_965)
  
  deriving instance GHC.Classes.Ord a_966 => GHC.Classes.Ord (Wildcard a_966)
  
  deriving instance GHC.Show.Show a_967 => GHC.Show.Show (Wildcard a_967)
  
  instance AST.Unmarshal.Unmarshal Wildcard
  
  instance Data.Foldable.Foldable Wildcard where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Wildcard where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Wildcard where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBang = AST.Token.Token "!" 51
  
  type AnonymousBangEqual = AST.Token.Token "!=" 33
  
  type AnonymousPercent = AST.Token.Token "%" 42
  
  type AnonymousPercentEqual = AST.Token.Token "%=" 24
  
  type AnonymousAmpersand = AST.Token.Token "&" 14
  
  type AnonymousAmpersandAmpersand = AST.Token.Token "&&" 34
  
  type AnonymousAmpersandEqual = AST.Token.Token "&=" 21
  
  type AnonymousLParen = AST.Token.Token "(" 13
  
  type AnonymousRParen = AST.Token.Token ")" 15
  
  type AnonymousStar = AST.Token.Token "*" 38
  
  type AnonymousStarEqual = AST.Token.Token "*=" 19
  
  type AnonymousPlus = AST.Token.Token "+" 36
  
  type AnonymousPlusPlus = AST.Token.Token "++" 53
  
  type AnonymousPlusEqual = AST.Token.Token "+=" 17
  
  type AnonymousComma = AST.Token.Token "," 48
  
  type AnonymousMinus = AST.Token.Token "-" 37
  
  type AnonymousMinusMinus = AST.Token.Token "--" 54
  
  type AnonymousMinusEqual = AST.Token.Token "-=" 18
  
  type AnonymousMinusRAngle = AST.Token.Token "->" 47
  
  type AnonymousDot = AST.Token.Token "." 58
  
  type AnonymousDotDotDot = AST.Token.Token "..." 118
  
  type AnonymousSlash = AST.Token.Token "/" 39
  
  type AnonymousSlashEqual = AST.Token.Token "/=" 20
  
  type AnonymousColon = AST.Token.Token ":" 50
  
  type AnonymousColonColon = AST.Token.Token "::" 60
  
  type AnonymousSemicolon = AST.Token.Token ";" 62
  
  type AnonymousLAngle = AST.Token.Token "<" 29
  
  type AnonymousLAngleLAngle = AST.Token.Token "<<" 43
  
  type AnonymousLAngleLAngleEqual = AST.Token.Token "<<=" 25
  
  type AnonymousLAngleEqual = AST.Token.Token "<=" 32
  
  type AnonymousEqual = AST.Token.Token "=" 16
  
  type AnonymousEqualEqual = AST.Token.Token "==" 30
  
  type AnonymousRAngle = AST.Token.Token ">" 28
  
  type AnonymousRAngleEqual = AST.Token.Token ">=" 31
  
  type AnonymousRAngleRAngle = AST.Token.Token ">>" 44
  
  type AnonymousRAngleRAngleEqual = AST.Token.Token ">>=" 26
  
  type AnonymousRAngleRAngleRAngle = AST.Token.Token ">>>" 45
  
  type AnonymousRAngleRAngleRAngleEqual = AST.Token.Token ">>>=" 27
  
  type AnonymousQuestion = AST.Token.Token "?" 49
  
  type AnonymousAt = AST.Token.Token "@" 82
  
  type AnonymousAtinterface = AST.Token.Token "@interface" 107
  
  type AnonymousLBracket = AST.Token.Token "[" 56
  
  type AnonymousRBracket = AST.Token.Token "]" 57
  
  type AnonymousCaret = AST.Token.Token "^" 41
  
  type AnonymousCaretEqual = AST.Token.Token "^=" 23
  
  type AnonymousAbstract = AST.Token.Token "abstract" 100
  
  type AnonymousAssert = AST.Token.Token "assert" 65
  
  data BinaryIntegerLiteral a = BinaryIntegerLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_968.
        AST.Traversable1.Class.Traversable1 a_968
      )
  
  instance AST.Unmarshal.SymbolMatching BinaryIntegerLiteral where
    matchedSymbols _ = [5]
    showFailure _ node_969 =
      "expected "
        GHC.Base.<> ( "binary_integer_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_969 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_969) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_970 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_971 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_972 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_973 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_970
          c1_971 = TreeSitter.Node.nodeStartPoint node_969
        TreeSitter.Node.TSPoint
          r2_972
          c2_973 = TreeSitter.Node.nodeEndPoint node_969
  
  deriving instance GHC.Classes.Eq a_974 => GHC.Classes.Eq (BinaryIntegerLiteral a_974)
  
  deriving instance GHC.Classes.Ord a_975 => GHC.Classes.Ord (BinaryIntegerLiteral a_975)
  
  deriving instance GHC.Show.Show a_976 => GHC.Show.Show (BinaryIntegerLiteral a_976)
  
  instance AST.Unmarshal.Unmarshal BinaryIntegerLiteral
  
  instance Data.Foldable.Foldable BinaryIntegerLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BinaryIntegerLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BinaryIntegerLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BooleanType a = BooleanType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_977.
        AST.Traversable1.Class.Traversable1 a_977
      )
  
  instance AST.Unmarshal.SymbolMatching BooleanType where
    matchedSymbols _ = [116]
    showFailure _ node_978 =
      "expected "
        GHC.Base.<> ( "boolean_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_978 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_978) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_979 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_980 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_981 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_982 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_979
          c1_980 = TreeSitter.Node.nodeStartPoint node_978
        TreeSitter.Node.TSPoint
          r2_981
          c2_982 = TreeSitter.Node.nodeEndPoint node_978
  
  deriving instance GHC.Classes.Eq a_983 => GHC.Classes.Eq (BooleanType a_983)
  
  deriving instance GHC.Classes.Ord a_984 => GHC.Classes.Ord (BooleanType a_984)
  
  deriving instance GHC.Show.Show a_985 => GHC.Show.Show (BooleanType a_985)
  
  instance AST.Unmarshal.Unmarshal BooleanType
  
  instance Data.Foldable.Foldable BooleanType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BooleanType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BooleanType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBreak = AST.Token.Token "break" 71
  
  type AnonymousByte = AST.Token.Token "byte" 109
  
  type AnonymousCase = AST.Token.Token "case" 67
  
  type AnonymousCatch = AST.Token.Token "catch" 77
  
  type AnonymousChar = AST.Token.Token "char" 113
  
  data CharacterLiteral a = CharacterLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_986.
        AST.Traversable1.Class.Traversable1 a_986
      )
  
  instance AST.Unmarshal.SymbolMatching CharacterLiteral where
    matchedSymbols _ = [10]
    showFailure _ node_987 =
      "expected "
        GHC.Base.<> ( "character_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_987 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_987) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_988 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_989 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_990 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_991 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_988
          c1_989 = TreeSitter.Node.nodeStartPoint node_987
        TreeSitter.Node.TSPoint
          r2_990
          c2_991 = TreeSitter.Node.nodeEndPoint node_987
  
  deriving instance GHC.Classes.Eq a_992 => GHC.Classes.Eq (CharacterLiteral a_992)
  
  deriving instance GHC.Classes.Ord a_993 => GHC.Classes.Ord (CharacterLiteral a_993)
  
  deriving instance GHC.Show.Show a_994 => GHC.Show.Show (CharacterLiteral a_994)
  
  instance AST.Unmarshal.Unmarshal CharacterLiteral
  
  instance Data.Foldable.Foldable CharacterLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CharacterLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CharacterLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousClass = AST.Token.Token "class" 59
  
  type AnonymousContinue = AST.Token.Token "continue" 72
  
  data DecimalFloatingPointLiteral a = DecimalFloatingPointLiteral
    { ann :: a,
      text :: Data.Text.Internal.Text
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_995.
        AST.Traversable1.Class.Traversable1 a_995
      )
  
  instance AST.Unmarshal.SymbolMatching DecimalFloatingPointLiteral where
    matchedSymbols _ = [6]
    showFailure _ node_996 =
      "expected "
        GHC.Base.<> ( "decimal_floating_point_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_996 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_996) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_997 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_998 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_999 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1000 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_997
          c1_998 = TreeSitter.Node.nodeStartPoint node_996
        TreeSitter.Node.TSPoint
          r2_999
          c2_1000 = TreeSitter.Node.nodeEndPoint node_996
  
  deriving instance GHC.Classes.Eq a_1001 => GHC.Classes.Eq (DecimalFloatingPointLiteral a_1001)
  
  deriving instance GHC.Classes.Ord a_1002 => GHC.Classes.Ord (DecimalFloatingPointLiteral a_1002)
  
  deriving instance GHC.Show.Show a_1003 => GHC.Show.Show (DecimalFloatingPointLiteral a_1003)
  
  instance AST.Unmarshal.Unmarshal DecimalFloatingPointLiteral
  
  instance Data.Foldable.Foldable DecimalFloatingPointLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DecimalFloatingPointLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DecimalFloatingPointLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DecimalIntegerLiteral a = DecimalIntegerLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1004.
        AST.Traversable1.Class.Traversable1 a_1004
      )
  
  instance AST.Unmarshal.SymbolMatching DecimalIntegerLiteral where
    matchedSymbols _ = [2]
    showFailure _ node_1005 =
      "expected "
        GHC.Base.<> ( "decimal_integer_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1005 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1005) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1006 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1007 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1008 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1009 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1006
          c1_1007 = TreeSitter.Node.nodeStartPoint node_1005
        TreeSitter.Node.TSPoint
          r2_1008
          c2_1009 = TreeSitter.Node.nodeEndPoint node_1005
  
  deriving instance GHC.Classes.Eq a_1010 => GHC.Classes.Eq (DecimalIntegerLiteral a_1010)
  
  deriving instance GHC.Classes.Ord a_1011 => GHC.Classes.Ord (DecimalIntegerLiteral a_1011)
  
  deriving instance GHC.Show.Show a_1012 => GHC.Show.Show (DecimalIntegerLiteral a_1012)
  
  instance AST.Unmarshal.Unmarshal DecimalIntegerLiteral
  
  instance Data.Foldable.Foldable DecimalIntegerLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DecimalIntegerLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DecimalIntegerLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousDefault = AST.Token.Token "default" 68
  
  type AnonymousDo = AST.Token.Token "do" 69
  
  type AnonymousDouble = AST.Token.Token "double" 115
  
  type AnonymousElse = AST.Token.Token "else" 80
  
  type AnonymousEnum = AST.Token.Token "enum" 96
  
  type AnonymousExports = AST.Token.Token "exports" 86
  
  type AnonymousExtends = AST.Token.Token "extends" 61
  
  data False a = False {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1013.
        AST.Traversable1.Class.Traversable1 a_1013
      )
  
  instance AST.Unmarshal.SymbolMatching False where
    matchedSymbols _ = [9]
    showFailure _ node_1014 =
      "expected "
        GHC.Base.<> ( "false"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1014 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1014) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1015 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1016 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1017 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1018 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1015
          c1_1016 = TreeSitter.Node.nodeStartPoint node_1014
        TreeSitter.Node.TSPoint
          r2_1017
          c2_1018 = TreeSitter.Node.nodeEndPoint node_1014
  
  deriving instance GHC.Classes.Eq a_1019 => GHC.Classes.Eq (False a_1019)
  
  deriving instance GHC.Classes.Ord a_1020 => GHC.Classes.Ord (False a_1020)
  
  deriving instance GHC.Show.Show a_1021 => GHC.Show.Show (False a_1021)
  
  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 AnonymousFinal = AST.Token.Token "final" 101
  
  type AnonymousFinally = AST.Token.Token "finally" 78
  
  type AnonymousFloat = AST.Token.Token "float" 114
  
  type AnonymousFor = AST.Token.Token "for" 81
  
  data HexFloatingPointLiteral a = HexFloatingPointLiteral
    { ann :: a,
      text :: Data.Text.Internal.Text
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1022.
        AST.Traversable1.Class.Traversable1 a_1022
      )
  
  instance AST.Unmarshal.SymbolMatching HexFloatingPointLiteral where
    matchedSymbols _ = [7]
    showFailure _ node_1023 =
      "expected "
        GHC.Base.<> ( "hex_floating_point_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1023 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1023) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1024 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1025 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1026 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1027 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1024
          c1_1025 = TreeSitter.Node.nodeStartPoint node_1023
        TreeSitter.Node.TSPoint
          r2_1026
          c2_1027 = TreeSitter.Node.nodeEndPoint node_1023
  
  deriving instance GHC.Classes.Eq a_1028 => GHC.Classes.Eq (HexFloatingPointLiteral a_1028)
  
  deriving instance GHC.Classes.Ord a_1029 => GHC.Classes.Ord (HexFloatingPointLiteral a_1029)
  
  deriving instance GHC.Show.Show a_1030 => GHC.Show.Show (HexFloatingPointLiteral a_1030)
  
  instance AST.Unmarshal.Unmarshal HexFloatingPointLiteral
  
  instance Data.Foldable.Foldable HexFloatingPointLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HexFloatingPointLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HexFloatingPointLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HexIntegerLiteral a = HexIntegerLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1031.
        AST.Traversable1.Class.Traversable1 a_1031
      )
  
  instance AST.Unmarshal.SymbolMatching HexIntegerLiteral where
    matchedSymbols _ = [3]
    showFailure _ node_1032 =
      "expected "
        GHC.Base.<> ( "hex_integer_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1032 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1032) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1033 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1034 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1035 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1036 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1033
          c1_1034 = TreeSitter.Node.nodeStartPoint node_1032
        TreeSitter.Node.TSPoint
          r2_1035
          c2_1036 = TreeSitter.Node.nodeEndPoint node_1032
  
  deriving instance GHC.Classes.Eq a_1037 => GHC.Classes.Eq (HexIntegerLiteral a_1037)
  
  deriving instance GHC.Classes.Ord a_1038 => GHC.Classes.Ord (HexIntegerLiteral a_1038)
  
  deriving instance GHC.Show.Show a_1039 => GHC.Show.Show (HexIntegerLiteral a_1039)
  
  instance AST.Unmarshal.Unmarshal HexIntegerLiteral
  
  instance Data.Foldable.Foldable HexIntegerLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HexIntegerLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HexIntegerLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Identifier a = Identifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1040.
        AST.Traversable1.Class.Traversable1 a_1040
      )
  
  instance AST.Unmarshal.SymbolMatching Identifier where
    matchedSymbols _ = [1]
    showFailure _ node_1041 =
      "expected "
        GHC.Base.<> ( "identifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1041 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1041) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1042 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1043 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1044 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1045 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1042
          c1_1043 = TreeSitter.Node.nodeStartPoint node_1041
        TreeSitter.Node.TSPoint
          r2_1044
          c2_1045 = TreeSitter.Node.nodeEndPoint node_1041
  
  deriving instance GHC.Classes.Eq a_1046 => GHC.Classes.Eq (Identifier a_1046)
  
  deriving instance GHC.Classes.Ord a_1047 => GHC.Classes.Ord (Identifier a_1047)
  
  deriving instance GHC.Show.Show a_1048 => GHC.Show.Show (Identifier a_1048)
  
  instance AST.Unmarshal.Unmarshal Identifier
  
  instance Data.Foldable.Foldable Identifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Identifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Identifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousIf = AST.Token.Token "if" 79
  
  type AnonymousImplements = AST.Token.Token "implements" 106
  
  type AnonymousImport = AST.Token.Token "import" 95
  
  type AnonymousInstanceof = AST.Token.Token "instanceof" 46
  
  type AnonymousInt = AST.Token.Token "int" 111
  
  type AnonymousInterface = AST.Token.Token "interface" 108
  
  type AnonymousLong = AST.Token.Token "long" 112
  
  type AnonymousModule = AST.Token.Token "module" 84
  
  type AnonymousNative = AST.Token.Token "native" 103
  
  type AnonymousNew = AST.Token.Token "new" 55
  
  data NullLiteral a = NullLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1049.
        AST.Traversable1.Class.Traversable1 a_1049
      )
  
  instance AST.Unmarshal.SymbolMatching NullLiteral where
    matchedSymbols _ = [12]
    showFailure _ node_1050 =
      "expected "
        GHC.Base.<> ( "null_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1050 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1050) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1051 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1052 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1053 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1054 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1051
          c1_1052 = TreeSitter.Node.nodeStartPoint node_1050
        TreeSitter.Node.TSPoint
          r2_1053
          c2_1054 = TreeSitter.Node.nodeEndPoint node_1050
  
  deriving instance GHC.Classes.Eq a_1055 => GHC.Classes.Eq (NullLiteral a_1055)
  
  deriving instance GHC.Classes.Ord a_1056 => GHC.Classes.Ord (NullLiteral a_1056)
  
  deriving instance GHC.Show.Show a_1057 => GHC.Show.Show (NullLiteral a_1057)
  
  instance AST.Unmarshal.Unmarshal NullLiteral
  
  instance Data.Foldable.Foldable NullLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NullLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NullLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data OctalIntegerLiteral a = OctalIntegerLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1058.
        AST.Traversable1.Class.Traversable1 a_1058
      )
  
  instance AST.Unmarshal.SymbolMatching OctalIntegerLiteral where
    matchedSymbols _ = [4]
    showFailure _ node_1059 =
      "expected "
        GHC.Base.<> ( "octal_integer_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1059 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1059) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1060 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1061 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1062 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1063 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1060
          c1_1061 = TreeSitter.Node.nodeStartPoint node_1059
        TreeSitter.Node.TSPoint
          r2_1062
          c2_1063 = TreeSitter.Node.nodeEndPoint node_1059
  
  deriving instance GHC.Classes.Eq a_1064 => GHC.Classes.Eq (OctalIntegerLiteral a_1064)
  
  deriving instance GHC.Classes.Ord a_1065 => GHC.Classes.Ord (OctalIntegerLiteral a_1065)
  
  deriving instance GHC.Show.Show a_1066 => GHC.Show.Show (OctalIntegerLiteral a_1066)
  
  instance AST.Unmarshal.Unmarshal OctalIntegerLiteral
  
  instance Data.Foldable.Foldable OctalIntegerLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OctalIntegerLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OctalIntegerLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousOpen = AST.Token.Token "open" 83
  
  type AnonymousOpens = AST.Token.Token "opens" 88
  
  type AnonymousPackage = AST.Token.Token "package" 94
  
  type AnonymousPrivate = AST.Token.Token "private" 99
  
  type AnonymousProtected = AST.Token.Token "protected" 98
  
  type AnonymousProvides = AST.Token.Token "provides" 90
  
  type AnonymousPublic = AST.Token.Token "public" 97
  
  type AnonymousRequires = AST.Token.Token "requires" 85
  
  type AnonymousReturn = AST.Token.Token "return" 73
  
  type AnonymousShort = AST.Token.Token "short" 110
  
  type AnonymousStatic = AST.Token.Token "static" 93
  
  type AnonymousStrictfp = AST.Token.Token "strictfp" 102
  
  data StringLiteral a = StringLiteral {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1067.
        AST.Traversable1.Class.Traversable1 a_1067
      )
  
  instance AST.Unmarshal.SymbolMatching StringLiteral where
    matchedSymbols _ = [11]
    showFailure _ node_1068 =
      "expected "
        GHC.Base.<> ( "string_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1068 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1068) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1069 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1070 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1071 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1072 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1069
          c1_1070 = TreeSitter.Node.nodeStartPoint node_1068
        TreeSitter.Node.TSPoint
          r2_1071
          c2_1072 = TreeSitter.Node.nodeEndPoint node_1068
  
  deriving instance GHC.Classes.Eq a_1073 => GHC.Classes.Eq (StringLiteral a_1073)
  
  deriving instance GHC.Classes.Ord a_1074 => GHC.Classes.Ord (StringLiteral a_1074)
  
  deriving instance GHC.Show.Show a_1075 => GHC.Show.Show (StringLiteral a_1075)
  
  instance AST.Unmarshal.Unmarshal StringLiteral
  
  instance Data.Foldable.Foldable StringLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor StringLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable StringLiteral 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_1076.
        AST.Traversable1.Class.Traversable1 a_1076
      )
  
  instance AST.Unmarshal.SymbolMatching Super where
    matchedSymbols _ = [121]
    showFailure _ node_1077 =
      "expected "
        GHC.Base.<> ( "super"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1077 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1077) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1078 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1079 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1080 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1081 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1078
          c1_1079 = TreeSitter.Node.nodeStartPoint node_1077
        TreeSitter.Node.TSPoint
          r2_1080
          c2_1081 = TreeSitter.Node.nodeEndPoint node_1077
  
  deriving instance GHC.Classes.Eq a_1082 => GHC.Classes.Eq (Super a_1082)
  
  deriving instance GHC.Classes.Ord a_1083 => GHC.Classes.Ord (Super a_1083)
  
  deriving instance GHC.Show.Show a_1084 => GHC.Show.Show (Super a_1084)
  
  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 AnonymousSwitch = AST.Token.Token "switch" 66
  
  type AnonymousSynchronized = AST.Token.Token "synchronized" 74
  
  data This a = This {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1085.
        AST.Traversable1.Class.Traversable1 a_1085
      )
  
  instance AST.Unmarshal.SymbolMatching This where
    matchedSymbols _ = [120]
    showFailure _ node_1086 =
      "expected "
        GHC.Base.<> ( "this"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1086 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1086) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1087 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1088 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1089 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1090 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1087
          c1_1088 = TreeSitter.Node.nodeStartPoint node_1086
        TreeSitter.Node.TSPoint
          r2_1089
          c2_1090 = TreeSitter.Node.nodeEndPoint node_1086
  
  deriving instance GHC.Classes.Eq a_1091 => GHC.Classes.Eq (This a_1091)
  
  deriving instance GHC.Classes.Ord a_1092 => GHC.Classes.Ord (This a_1092)
  
  deriving instance GHC.Show.Show a_1093 => GHC.Show.Show (This a_1093)
  
  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
  
  type AnonymousThrow = AST.Token.Token "throw" 75
  
  type AnonymousThrows = AST.Token.Token "throws" 119
  
  type AnonymousTo = AST.Token.Token "to" 87
  
  type AnonymousTransient = AST.Token.Token "transient" 104
  
  type AnonymousTransitive = AST.Token.Token "transitive" 92
  
  data True a = True {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1094.
        AST.Traversable1.Class.Traversable1 a_1094
      )
  
  instance AST.Unmarshal.SymbolMatching True where
    matchedSymbols _ = [8]
    showFailure _ node_1095 =
      "expected "
        GHC.Base.<> ( "true"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1095 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1095) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1096 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1097 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1098 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1099 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1096
          c1_1097 = TreeSitter.Node.nodeStartPoint node_1095
        TreeSitter.Node.TSPoint
          r2_1098
          c2_1099 = TreeSitter.Node.nodeEndPoint node_1095
  
  deriving instance GHC.Classes.Eq a_1100 => GHC.Classes.Eq (True a_1100)
  
  deriving instance GHC.Classes.Ord a_1101 => GHC.Classes.Ord (True a_1101)
  
  deriving instance GHC.Show.Show a_1102 => GHC.Show.Show (True a_1102)
  
  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
  
  type AnonymousTry = AST.Token.Token "try" 76
  
  data TypeIdentifier a = TypeIdentifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1103.
        AST.Traversable1.Class.Traversable1 a_1103
      )
  
  instance AST.Unmarshal.SymbolMatching TypeIdentifier where
    matchedSymbols _ = [274]
    showFailure _ node_1104 =
      "expected "
        GHC.Base.<> ( "type_identifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1104 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1104) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1105 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1106 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1107 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1108 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1105
          c1_1106 = TreeSitter.Node.nodeStartPoint node_1104
        TreeSitter.Node.TSPoint
          r2_1107
          c2_1108 = TreeSitter.Node.nodeEndPoint node_1104
  
  deriving instance GHC.Classes.Eq a_1109 => GHC.Classes.Eq (TypeIdentifier a_1109)
  
  deriving instance GHC.Classes.Ord a_1110 => GHC.Classes.Ord (TypeIdentifier a_1110)
  
  deriving instance GHC.Show.Show a_1111 => GHC.Show.Show (TypeIdentifier a_1111)
  
  instance AST.Unmarshal.Unmarshal TypeIdentifier
  
  instance Data.Foldable.Foldable TypeIdentifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeIdentifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeIdentifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousUses = AST.Token.Token "uses" 89
  
  data VoidType a = VoidType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1112.
        AST.Traversable1.Class.Traversable1 a_1112
      )
  
  instance AST.Unmarshal.SymbolMatching VoidType where
    matchedSymbols _ = [117]
    showFailure _ node_1113 =
      "expected "
        GHC.Base.<> ( "void_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1113 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1113) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1114 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1115 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1116 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1117 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1114
          c1_1115 = TreeSitter.Node.nodeStartPoint node_1113
        TreeSitter.Node.TSPoint
          r2_1116
          c2_1117 = TreeSitter.Node.nodeEndPoint node_1113
  
  deriving instance GHC.Classes.Eq a_1118 => GHC.Classes.Eq (VoidType a_1118)
  
  deriving instance GHC.Classes.Ord a_1119 => GHC.Classes.Ord (VoidType a_1119)
  
  deriving instance GHC.Show.Show a_1120 => GHC.Show.Show (VoidType a_1120)
  
  instance AST.Unmarshal.Unmarshal VoidType
  
  instance Data.Foldable.Foldable VoidType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VoidType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VoidType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousVolatile = AST.Token.Token "volatile" 105
  
  type AnonymousWhile = AST.Token.Token "while" 70
  
  type AnonymousWith = AST.Token.Token "with" 91
  
  type AnonymousLBrace = AST.Token.Token "{" 63
  
  type AnonymousPipe = AST.Token.Token "|" 40
  
  type AnonymousPipeEqual = AST.Token.Token "|=" 22
  
  type AnonymousPipePipe = AST.Token.Token "||" 35
  
  type AnonymousRBrace = AST.Token.Token "}" 64
  
  type AnonymousTilde = AST.Token.Token "~" 52
  