content: -- Language definition for PHP, 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.PHP.AST (module Language.PHP.AST) where
  
  import qualified AST.Parse
  import qualified AST.Token
  import qualified AST.Traversable1.Class
  import qualified AST.Unmarshal
  import qualified Data.Foldable
  import qualified Data.List as Data.OldList
  import qualified Data.Maybe as GHC.Maybe
  import qualified Data.Text.Internal
  import qualified Data.Traversable
  import qualified GHC.Base
  import qualified GHC.Generics
  import qualified GHC.Records
  import qualified GHC.Show
  import qualified TreeSitter.Node
  import qualified Prelude as GHC.Classes
  
  debugSymbolNames :: [GHC.Base.String]
  debugSymbolNames = debugSymbolNames_0
  
  debugSymbolNames_0 :: [GHC.Base.String]
  debugSymbolNames_0 =
    [ "end",
      "name",
      "php_tag",
      "_?>",
      "_text_token1",
      "_text_token2",
      "_;",
      "_static",
      "_,",
      "_=",
      "_global",
      "_namespace",
      "_use",
      "_\\",
      "_function",
      "_const",
      "_as",
      "_{",
      "_}",
      "_trait",
      "_interface",
      "_extends",
      "_class",
      "_abstract",
      "_final",
      "_implements",
      "var_modifier",
      "_insteadof",
      "_public",
      "_protected",
      "_private",
      "_&",
      "_(",
      "_)",
      "_...",
      "_?",
      "_array",
      "_callable",
      "_iterable",
      "_bool",
      "_float",
      "_int",
      "_string",
      "_void",
      "_binary",
      "_boolean",
      "_double",
      "_integer",
      "_object",
      "_real",
      "_unset",
      "_:",
      "_echo",
      "_declare",
      "_enddeclare",
      "_ticks",
      "_encoding",
      "_strict_types",
      "float",
      "_try",
      "_catch",
      "_finally",
      "_goto",
      "_continue",
      "_break",
      "integer",
      "_return",
      "_throw",
      "_while",
      "_endwhile",
      "_do",
      "_for",
      "_endfor",
      "_foreach",
      "_endforeach",
      "_=>",
      "_if",
      "_endif",
      "_elseif",
      "_else",
      "_switch",
      "_endswitch",
      "_case",
      "_default",
      "_@",
      "_+",
      "_-",
      "_~",
      "_!",
      "_**",
      "_clone",
      "_::",
      "_print",
      "_new",
      "_++",
      "_--",
      "shell_command_expression",
      "_**=",
      "_*=",
      "_/=",
      "_%=",
      "_+=",
      "_-=",
      "_.=",
      "_<<=",
      "_>>=",
      "_&=",
      "_^=",
      "_|=",
      "_->",
      "_list",
      "_self",
      "_parent",
      "_[",
      "_]",
      "string",
      "boolean",
      "null",
      "_$",
      "_yield",
      "_from",
      "_instanceof",
      "_??",
      "_and",
      "_or",
      "_xor",
      "_||",
      "_&&",
      "_|",
      "_^",
      "_==",
      "_!=",
      "_<>",
      "_===",
      "_!==",
      "_<",
      "_>",
      "_<=",
      "_>=",
      "_<=>",
      "_<<",
      "_>>",
      "_.",
      "_*",
      "_/",
      "_%",
      "_include",
      "_include_once",
      "_require",
      "_require_once",
      "comment",
      "_automatic_semicolon",
      "heredoc",
      "_eof",
      "program",
      "text_interpolation",
      "text",
      "empty_statement",
      "function_static_declaration",
      "static_variable_declaration",
      "global_declaration",
      "namespace_definition",
      "namespace_use_declaration",
      "namespace_function_or_const",
      "namespace_use_clause",
      "qualified_name",
      "namespace_name_as_prefix",
      "namespace_name",
      "namespace_aliasing_clause",
      "namespace_use_group",
      "namespace_use_group_clause",
      "trait_declaration",
      "interface_declaration",
      "interface_base_clause",
      "class_declaration",
      "declaration_list",
      "class_modifier",
      "class_base_clause",
      "class_interface_clause",
      "_member_declaration",
      "const_declaration",
      "property_declaration",
      "_modifier",
      "property_element",
      "property_initializer",
      "method_declaration",
      "static_modifier",
      "use_declaration",
      "use_list",
      "use_instead_of_clause",
      "use_as_clause",
      "visibility_modifier",
      "function_definition",
      "_function_definition_header",
      "formal_parameters",
      "simple_parameter",
      "variadic_parameter",
      "_type",
      "optional_type",
      "primitive_type",
      "cast_type",
      "_return_type",
      "const_element",
      "echo_statement",
      "unset_statement",
      "declare_statement",
      "declare_directive",
      "try_statement",
      "catch_clause",
      "finally_clause",
      "_jump_statement",
      "goto_statement",
      "continue_statement",
      "break_statement",
      "return_statement",
      "throw_statement",
      "while_statement",
      "do_statement",
      "for_statement",
      "_expressions",
      "sequence_expression",
      "foreach_statement",
      "pair",
      "if_statement",
      "colon_block",
      "else_if_clause",
      "else_clause",
      "else_if_clause",
      "else_clause",
      "switch_statement",
      "switch_block",
      "case_statement",
      "default_statement",
      "compound_statement",
      "named_label_statement",
      "expression_statement",
      "_expression",
      "_unary_expression",
      "unary_op_expression",
      "exponentiation_expression",
      "clone_expression",
      "_primary_expression",
      "parenthesized_expression",
      "class_constant_access_expression",
      "print_intrinsic",
      "anonymous_function_creation_expression",
      "anonymous_function_use_clause",
      "object_creation_expression",
      "update_expression",
      "cast_expression",
      "cast_expression",
      "assignment_expression",
      "conditional_expression",
      "augmented_assignment_expression",
      "member_access_expression",
      "scoped_property_access_expression",
      "list_literal",
      "function_call_expression",
      "scoped_call_expression",
      "_scope_resolution_qualifier",
      "relative_scope",
      "arguments",
      "member_call_expression",
      "variadic_unpacking",
      "subscript_expression",
      "_dereferencable_expression",
      "array_creation_expression",
      "_string",
      "dynamic_variable_name",
      "variable_name",
      "yield_expression",
      "array_element_initializer",
      "binary_expression",
      "include_expression",
      "include_once_expression",
      "require_expression",
      "require_once_expression",
      "name",
      "_program_repeat1",
      "_text_repeat1",
      "_function_static_declaration_repeat1",
      "_global_declaration_repeat1",
      "_namespace_use_declaration_repeat1",
      "_namespace_name_repeat1",
      "_namespace_use_group_repeat1",
      "_interface_base_clause_repeat1",
      "_declaration_list_repeat1",
      "_const_declaration_repeat1",
      "_property_declaration_repeat1",
      "_property_declaration_repeat2",
      "_use_list_repeat1",
      "_formal_parameters_repeat1",
      "_unset_statement_repeat1",
      "_try_statement_repeat1",
      "_if_statement_repeat1",
      "_if_statement_repeat2",
      "_switch_block_repeat1",
      "_anonymous_function_use_clause_repeat1",
      "_list_literal_repeat1",
      "_arguments_repeat1",
      "_array_creation_expression_repeat1",
      "type_name"
    ]
  
  newtype Expression a = Expression {getExpression :: ((PrimaryExpression GHC.Generics.:+: AssignmentExpression GHC.Generics.:+: AugmentedAssignmentExpression GHC.Generics.:+: BinaryExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: CloneExpression GHC.Generics.:+: ConditionalExpression GHC.Generics.:+: ExponentiationExpression GHC.Generics.:+: IncludeExpression GHC.Generics.:+: IncludeOnceExpression GHC.Generics.:+: RequireExpression GHC.Generics.:+: RequireOnceExpression GHC.Generics.:+: UnaryOpExpression GHC.Generics.:+: YieldExpression) 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" (Expression a_2) a_2 where
    getField = AST.Unmarshal.gann GHC.Base.. getExpression
  
  deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (Expression a_3)
  
  deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (Expression a_4)
  
  deriving instance GHC.Show.Show a_5 => GHC.Show.Show (Expression a_5)
  
  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 :: ((Boolean GHC.Generics.:+: Float GHC.Generics.:+: Heredoc GHC.Generics.:+: Integer GHC.Generics.:+: Null GHC.Generics.:+: String) 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" (Literal a_7) a_7 where
    getField = AST.Unmarshal.gann GHC.Base.. getLiteral
  
  deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (Literal a_8)
  
  deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (Literal a_9)
  
  deriving instance GHC.Show.Show a_10 => GHC.Show.Show (Literal a_10)
  
  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 PrimaryExpression a = PrimaryExpression {getPrimaryExpression :: ((Literal GHC.Generics.:+: AnonymousFunctionCreationExpression GHC.Generics.:+: ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ObjectCreationExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: PrintIntrinsic GHC.Generics.:+: QualifiedName GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: ShellCommandExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: UpdateExpression GHC.Generics.:+: VariableName) 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" (PrimaryExpression a_12) a_12 where
    getField = AST.Unmarshal.gann GHC.Base.. getPrimaryExpression
  
  deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (PrimaryExpression a_13)
  
  deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (PrimaryExpression a_14)
  
  deriving instance GHC.Show.Show a_15 => GHC.Show.Show (PrimaryExpression a_15)
  
  instance AST.Unmarshal.Unmarshal PrimaryExpression
  
  instance Data.Foldable.Foldable PrimaryExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PrimaryExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PrimaryExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Statement a = Statement {getStatement :: ((BreakStatement GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: CompoundStatement GHC.Generics.:+: ConstDeclaration GHC.Generics.:+: ContinueStatement GHC.Generics.:+: DeclareStatement GHC.Generics.:+: DoStatement GHC.Generics.:+: EchoStatement GHC.Generics.:+: EmptyStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: ForStatement GHC.Generics.:+: ForeachStatement GHC.Generics.:+: FunctionDefinition GHC.Generics.:+: FunctionStaticDeclaration GHC.Generics.:+: GlobalDeclaration GHC.Generics.:+: GotoStatement GHC.Generics.:+: IfStatement GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: NamedLabelStatement GHC.Generics.:+: NamespaceDefinition GHC.Generics.:+: NamespaceUseDeclaration GHC.Generics.:+: ReturnStatement GHC.Generics.:+: SwitchStatement GHC.Generics.:+: ThrowStatement GHC.Generics.:+: TraitDeclaration GHC.Generics.:+: TryStatement GHC.Generics.:+: UnsetStatement GHC.Generics.:+: WhileStatement) 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" (Statement a_17) a_17 where
    getField = AST.Unmarshal.gann GHC.Base.. getStatement
  
  deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (Statement a_18)
  
  deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (Statement a_19)
  
  deriving instance GHC.Show.Show a_20 => GHC.Show.Show (Statement a_20)
  
  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 :: ((OptionalType GHC.Generics.:+: PrimitiveType GHC.Generics.:+: TypeName) 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" (Type a_22) a_22 where
    getField = AST.Unmarshal.gann GHC.Base.. getType
  
  deriving instance GHC.Classes.Eq a_23 => GHC.Classes.Eq (Type a_23)
  
  deriving instance GHC.Classes.Ord a_24 => GHC.Classes.Ord (Type a_24)
  
  deriving instance GHC.Show.Show a_25 => GHC.Show.Show (Type a_25)
  
  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
  
  data AnonymousFunctionCreationExpression a = AnonymousFunctionCreationExpression
    { ann :: a,
      returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a))),
      body :: (AST.Parse.Err (CompoundStatement a)),
      parameters :: (AST.Parse.Err (FormalParameters a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (AnonymousFunctionUseClause a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_26.
        AST.Traversable1.Class.Traversable1 a_26
      )
  
  instance AST.Unmarshal.SymbolMatching AnonymousFunctionCreationExpression where
    matchedSymbols _ = [245]
    showFailure _ node_27 =
      "expected "
        GHC.Base.<> ( "anonymous_function_creation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_27 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_27) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_28 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_29 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_30 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_31 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_28
          c1_29 = TreeSitter.Node.nodeStartPoint node_27
        TreeSitter.Node.TSPoint
          r2_30
          c2_31 = TreeSitter.Node.nodeEndPoint node_27
  
  deriving instance GHC.Classes.Eq a_32 => GHC.Classes.Eq (AnonymousFunctionCreationExpression a_32)
  
  deriving instance GHC.Classes.Ord a_33 => GHC.Classes.Ord (AnonymousFunctionCreationExpression a_33)
  
  deriving instance GHC.Show.Show a_34 => GHC.Show.Show (AnonymousFunctionCreationExpression a_34)
  
  instance AST.Unmarshal.Unmarshal AnonymousFunctionCreationExpression
  
  instance Data.Foldable.Foldable AnonymousFunctionCreationExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnonymousFunctionCreationExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnonymousFunctionCreationExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AnonymousFunctionUseClause a = AnonymousFunctionUseClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_35.
        AST.Traversable1.Class.Traversable1 a_35
      )
  
  instance AST.Unmarshal.SymbolMatching AnonymousFunctionUseClause where
    matchedSymbols _ = [246]
    showFailure _ node_36 =
      "expected "
        GHC.Base.<> ( "anonymous_function_use_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_36 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_36) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_37 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_38 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_39 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_40 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_37
          c1_38 = TreeSitter.Node.nodeStartPoint node_36
        TreeSitter.Node.TSPoint
          r2_39
          c2_40 = TreeSitter.Node.nodeEndPoint node_36
  
  deriving instance GHC.Classes.Eq a_41 => GHC.Classes.Eq (AnonymousFunctionUseClause a_41)
  
  deriving instance GHC.Classes.Ord a_42 => GHC.Classes.Ord (AnonymousFunctionUseClause a_42)
  
  deriving instance GHC.Show.Show a_43 => GHC.Show.Show (AnonymousFunctionUseClause a_43)
  
  instance AST.Unmarshal.Unmarshal AnonymousFunctionUseClause
  
  instance Data.Foldable.Foldable AnonymousFunctionUseClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AnonymousFunctionUseClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AnonymousFunctionUseClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Arguments a = Arguments
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: VariadicUnpacking) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_44.
        AST.Traversable1.Class.Traversable1 a_44
      )
  
  instance AST.Unmarshal.SymbolMatching Arguments where
    matchedSymbols _ = [261]
    showFailure _ node_45 =
      "expected "
        GHC.Base.<> ( "arguments"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_45 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_45) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_46 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_47 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_48 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_49 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_46
          c1_47 = TreeSitter.Node.nodeStartPoint node_45
        TreeSitter.Node.TSPoint
          r2_48
          c2_49 = TreeSitter.Node.nodeEndPoint node_45
  
  deriving instance GHC.Classes.Eq a_50 => GHC.Classes.Eq (Arguments a_50)
  
  deriving instance GHC.Classes.Ord a_51 => GHC.Classes.Ord (Arguments a_51)
  
  deriving instance GHC.Show.Show a_52 => GHC.Show.Show (Arguments a_52)
  
  instance AST.Unmarshal.Unmarshal Arguments
  
  instance Data.Foldable.Foldable Arguments where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Arguments where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Arguments where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArrayCreationExpression a = ArrayCreationExpression
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (ArrayElementInitializer a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_53.
        AST.Traversable1.Class.Traversable1 a_53
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayCreationExpression where
    matchedSymbols _ = [266]
    showFailure _ node_54 =
      "expected "
        GHC.Base.<> ( "array_creation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_54 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_54) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_55 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_56 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_57 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_58 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_55
          c1_56 = TreeSitter.Node.nodeStartPoint node_54
        TreeSitter.Node.TSPoint
          r2_57
          c2_58 = TreeSitter.Node.nodeEndPoint node_54
  
  deriving instance GHC.Classes.Eq a_59 => GHC.Classes.Eq (ArrayCreationExpression a_59)
  
  deriving instance GHC.Classes.Ord a_60 => GHC.Classes.Ord (ArrayCreationExpression a_60)
  
  deriving instance GHC.Show.Show a_61 => GHC.Show.Show (ArrayCreationExpression a_61)
  
  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 ArrayElementInitializer a = ArrayElementInitializer
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_62.
        AST.Traversable1.Class.Traversable1 a_62
      )
  
  instance AST.Unmarshal.SymbolMatching ArrayElementInitializer where
    matchedSymbols _ = [271]
    showFailure _ node_63 =
      "expected "
        GHC.Base.<> ( "array_element_initializer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_63 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_63) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_64 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_65 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_66 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_67 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_64
          c1_65 = TreeSitter.Node.nodeStartPoint node_63
        TreeSitter.Node.TSPoint
          r2_66
          c2_67 = TreeSitter.Node.nodeEndPoint node_63
  
  deriving instance GHC.Classes.Eq a_68 => GHC.Classes.Eq (ArrayElementInitializer a_68)
  
  deriving instance GHC.Classes.Ord a_69 => GHC.Classes.Ord (ArrayElementInitializer a_69)
  
  deriving instance GHC.Show.Show a_70 => GHC.Show.Show (ArrayElementInitializer a_70)
  
  instance AST.Unmarshal.Unmarshal ArrayElementInitializer
  
  instance Data.Foldable.Foldable ArrayElementInitializer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArrayElementInitializer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArrayElementInitializer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AssignmentExpression a = AssignmentExpression
    { ann :: a,
      left :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: ListLiteral GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)),
      right :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_71.
        AST.Traversable1.Class.Traversable1 a_71
      )
  
  instance AST.Unmarshal.SymbolMatching AssignmentExpression where
    matchedSymbols _ = [251]
    showFailure _ node_72 =
      "expected "
        GHC.Base.<> ( "assignment_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_72 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_72) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_73 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_74 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_75 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_76 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_73
          c1_74 = TreeSitter.Node.nodeStartPoint node_72
        TreeSitter.Node.TSPoint
          r2_75
          c2_76 = TreeSitter.Node.nodeEndPoint node_72
  
  deriving instance GHC.Classes.Eq a_77 => GHC.Classes.Eq (AssignmentExpression a_77)
  
  deriving instance GHC.Classes.Ord a_78 => GHC.Classes.Ord (AssignmentExpression a_78)
  
  deriving instance GHC.Show.Show a_79 => GHC.Show.Show (AssignmentExpression a_79)
  
  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 AugmentedAssignmentExpression a = AugmentedAssignmentExpression
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousPercentEqual GHC.Generics.:+: AnonymousAmpersandEqual GHC.Generics.:+: AnonymousStarStarEqual GHC.Generics.:+: AnonymousStarEqual GHC.Generics.:+: AnonymousPlusEqual GHC.Generics.:+: AnonymousMinusEqual GHC.Generics.:+: AnonymousDotEqual GHC.Generics.:+: AnonymousSlashEqual GHC.Generics.:+: AnonymousLAngleLAngleEqual GHC.Generics.:+: AnonymousRAngleRAngleEqual GHC.Generics.:+: AnonymousCaretEqual GHC.Generics.:+: AnonymousPipeEqual) a)),
      left :: (AST.Parse.Err ((CastExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)),
      right :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_80.
        AST.Traversable1.Class.Traversable1 a_80
      )
  
  instance AST.Unmarshal.SymbolMatching AugmentedAssignmentExpression where
    matchedSymbols _ = [253]
    showFailure _ node_81 =
      "expected "
        GHC.Base.<> ( "augmented_assignment_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_81 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_81) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_82 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_83 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_84 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_85 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_82
          c1_83 = TreeSitter.Node.nodeStartPoint node_81
        TreeSitter.Node.TSPoint
          r2_84
          c2_85 = TreeSitter.Node.nodeEndPoint node_81
  
  deriving instance GHC.Classes.Eq a_86 => GHC.Classes.Eq (AugmentedAssignmentExpression a_86)
  
  deriving instance GHC.Classes.Ord a_87 => GHC.Classes.Ord (AugmentedAssignmentExpression a_87)
  
  deriving instance GHC.Show.Show a_88 => GHC.Show.Show (AugmentedAssignmentExpression a_88)
  
  instance AST.Unmarshal.Unmarshal AugmentedAssignmentExpression
  
  instance Data.Foldable.Foldable AugmentedAssignmentExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AugmentedAssignmentExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AugmentedAssignmentExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BinaryExpression a = BinaryExpression
    { ann :: a,
      operator :: (GHC.Maybe.Maybe (AST.Parse.Err ((AnonymousBangEqual GHC.Generics.:+: AnonymousBangEqualEqual GHC.Generics.:+: AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousAmpersandAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousDot GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousLAngle GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousLAngleEqual GHC.Generics.:+: AnonymousLAngleEqualRAngle GHC.Generics.:+: AnonymousLAngleRAngle GHC.Generics.:+: AnonymousEqualEqual GHC.Generics.:+: AnonymousEqualEqualEqual GHC.Generics.:+: AnonymousRAngle GHC.Generics.:+: AnonymousRAngleEqual GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousAnd GHC.Generics.:+: AnonymousInstanceof GHC.Generics.:+: AnonymousOr GHC.Generics.:+: AnonymousXor GHC.Generics.:+: AnonymousPipe GHC.Generics.:+: AnonymousPipePipe) a))),
      left :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      right :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))),
      extraChildren :: ([AST.Parse.Err (Expression a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_89.
        AST.Traversable1.Class.Traversable1 a_89
      )
  
  instance AST.Unmarshal.SymbolMatching BinaryExpression where
    matchedSymbols _ = [272]
    showFailure _ node_90 =
      "expected "
        GHC.Base.<> ( "binary_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_90 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_90) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_91 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_92 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_93 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_94 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_91
          c1_92 = TreeSitter.Node.nodeStartPoint node_90
        TreeSitter.Node.TSPoint
          r2_93
          c2_94 = TreeSitter.Node.nodeEndPoint node_90
  
  deriving instance GHC.Classes.Eq a_95 => GHC.Classes.Eq (BinaryExpression a_95)
  
  deriving instance GHC.Classes.Ord a_96 => GHC.Classes.Ord (BinaryExpression a_96)
  
  deriving instance GHC.Show.Show a_97 => GHC.Show.Show (BinaryExpression a_97)
  
  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 BreakStatement a = BreakStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_98.
        AST.Traversable1.Class.Traversable1 a_98
      )
  
  instance AST.Unmarshal.SymbolMatching BreakStatement where
    matchedSymbols _ = [213]
    showFailure _ node_99 =
      "expected "
        GHC.Base.<> ( "break_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_99 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_99) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_100 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_101 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_102 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_103 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_100
          c1_101 = TreeSitter.Node.nodeStartPoint node_99
        TreeSitter.Node.TSPoint
          r2_102
          c2_103 = TreeSitter.Node.nodeEndPoint node_99
  
  deriving instance GHC.Classes.Eq a_104 => GHC.Classes.Eq (BreakStatement a_104)
  
  deriving instance GHC.Classes.Ord a_105 => GHC.Classes.Ord (BreakStatement a_105)
  
  deriving instance GHC.Show.Show a_106 => GHC.Show.Show (BreakStatement a_106)
  
  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 CaseStatement a = CaseStatement
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_107.
        AST.Traversable1.Class.Traversable1 a_107
      )
  
  instance AST.Unmarshal.SymbolMatching CaseStatement where
    matchedSymbols _ = [231]
    showFailure _ node_108 =
      "expected "
        GHC.Base.<> ( "case_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_108 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_108) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_109 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_110 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_111 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_112 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_109
          c1_110 = TreeSitter.Node.nodeStartPoint node_108
        TreeSitter.Node.TSPoint
          r2_111
          c2_112 = TreeSitter.Node.nodeEndPoint node_108
  
  deriving instance GHC.Classes.Eq a_113 => GHC.Classes.Eq (CaseStatement a_113)
  
  deriving instance GHC.Classes.Ord a_114 => GHC.Classes.Ord (CaseStatement a_114)
  
  deriving instance GHC.Show.Show a_115 => GHC.Show.Show (CaseStatement a_115)
  
  instance AST.Unmarshal.Unmarshal CaseStatement
  
  instance Data.Foldable.Foldable CaseStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CaseStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CaseStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CastExpression a = CastExpression
    { ann :: a,
      value :: (AST.Parse.Err ((PrimaryExpression GHC.Generics.:+: CloneExpression GHC.Generics.:+: ExponentiationExpression GHC.Generics.:+: UnaryOpExpression) a)),
      type' :: (AST.Parse.Err (CastType a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_116.
        AST.Traversable1.Class.Traversable1 a_116
      )
  
  instance AST.Unmarshal.SymbolMatching CastExpression where
    matchedSymbols _ = [249, 250]
    showFailure _ node_117 =
      "expected "
        GHC.Base.<> ( "cast_expression, cast_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_117 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_117) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_118 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_119 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_120 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_121 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_118
          c1_119 = TreeSitter.Node.nodeStartPoint node_117
        TreeSitter.Node.TSPoint
          r2_120
          c2_121 = TreeSitter.Node.nodeEndPoint node_117
  
  deriving instance GHC.Classes.Eq a_122 => GHC.Classes.Eq (CastExpression a_122)
  
  deriving instance GHC.Classes.Ord a_123 => GHC.Classes.Ord (CastExpression a_123)
  
  deriving instance GHC.Show.Show a_124 => GHC.Show.Show (CastExpression a_124)
  
  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 CastType a = CastType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_125.
        AST.Traversable1.Class.Traversable1 a_125
      )
  
  instance AST.Unmarshal.SymbolMatching CastType where
    matchedSymbols _ = [200]
    showFailure _ node_126 =
      "expected "
        GHC.Base.<> ( "cast_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_126 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_126) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_127 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_128 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_129 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_130 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_127
          c1_128 = TreeSitter.Node.nodeStartPoint node_126
        TreeSitter.Node.TSPoint
          r2_129
          c2_130 = TreeSitter.Node.nodeEndPoint node_126
  
  deriving instance GHC.Classes.Eq a_131 => GHC.Classes.Eq (CastType a_131)
  
  deriving instance GHC.Classes.Ord a_132 => GHC.Classes.Ord (CastType a_132)
  
  deriving instance GHC.Show.Show a_133 => GHC.Show.Show (CastType a_133)
  
  instance AST.Unmarshal.Unmarshal CastType
  
  instance Data.Foldable.Foldable CastType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CastType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CastType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CatchClause a = CatchClause
    { ann :: a,
      body :: (AST.Parse.Err (CompoundStatement a)),
      name :: (AST.Parse.Err (VariableName a)),
      type' :: (AST.Parse.Err (TypeName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_134.
        AST.Traversable1.Class.Traversable1 a_134
      )
  
  instance AST.Unmarshal.SymbolMatching CatchClause where
    matchedSymbols _ = [208]
    showFailure _ node_135 =
      "expected "
        GHC.Base.<> ( "catch_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_135 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_135) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_136 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_137 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_138 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_139 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_136
          c1_137 = TreeSitter.Node.nodeStartPoint node_135
        TreeSitter.Node.TSPoint
          r2_138
          c2_139 = TreeSitter.Node.nodeEndPoint node_135
  
  deriving instance GHC.Classes.Eq a_140 => GHC.Classes.Eq (CatchClause a_140)
  
  deriving instance GHC.Classes.Ord a_141 => GHC.Classes.Ord (CatchClause a_141)
  
  deriving instance GHC.Show.Show a_142 => GHC.Show.Show (CatchClause a_142)
  
  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 ClassBaseClause a = ClassBaseClause
    { ann :: a,
      extraChildren :: (AST.Parse.Err (QualifiedName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_143.
        AST.Traversable1.Class.Traversable1 a_143
      )
  
  instance AST.Unmarshal.SymbolMatching ClassBaseClause where
    matchedSymbols _ = [177]
    showFailure _ node_144 =
      "expected "
        GHC.Base.<> ( "class_base_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_144 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_144) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_145 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_146 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_147 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_148 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_145
          c1_146 = TreeSitter.Node.nodeStartPoint node_144
        TreeSitter.Node.TSPoint
          r2_147
          c2_148 = TreeSitter.Node.nodeEndPoint node_144
  
  deriving instance GHC.Classes.Eq a_149 => GHC.Classes.Eq (ClassBaseClause a_149)
  
  deriving instance GHC.Classes.Ord a_150 => GHC.Classes.Ord (ClassBaseClause a_150)
  
  deriving instance GHC.Show.Show a_151 => GHC.Show.Show (ClassBaseClause a_151)
  
  instance AST.Unmarshal.Unmarshal ClassBaseClause
  
  instance Data.Foldable.Foldable ClassBaseClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassBaseClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassBaseClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassConstantAccessExpression a = ClassConstantAccessExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: Name GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: RelativeScope GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_152.
        AST.Traversable1.Class.Traversable1 a_152
      )
  
  instance AST.Unmarshal.SymbolMatching ClassConstantAccessExpression where
    matchedSymbols _ = [243]
    showFailure _ node_153 =
      "expected "
        GHC.Base.<> ( "class_constant_access_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_153 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_153) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_154 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_155 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_156 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_157 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_154
          c1_155 = TreeSitter.Node.nodeStartPoint node_153
        TreeSitter.Node.TSPoint
          r2_156
          c2_157 = TreeSitter.Node.nodeEndPoint node_153
  
  deriving instance GHC.Classes.Eq a_158 => GHC.Classes.Eq (ClassConstantAccessExpression a_158)
  
  deriving instance GHC.Classes.Ord a_159 => GHC.Classes.Ord (ClassConstantAccessExpression a_159)
  
  deriving instance GHC.Show.Show a_160 => GHC.Show.Show (ClassConstantAccessExpression a_160)
  
  instance AST.Unmarshal.Unmarshal ClassConstantAccessExpression
  
  instance Data.Foldable.Foldable ClassConstantAccessExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassConstantAccessExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassConstantAccessExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassDeclaration a = ClassDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (DeclarationList a)),
      name :: (AST.Parse.Err (Name a)),
      extraChildren :: ([AST.Parse.Err ((ClassBaseClause GHC.Generics.:+: ClassInterfaceClause GHC.Generics.:+: ClassModifier) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_161.
        AST.Traversable1.Class.Traversable1 a_161
      )
  
  instance AST.Unmarshal.SymbolMatching ClassDeclaration where
    matchedSymbols _ = [174]
    showFailure _ node_162 =
      "expected "
        GHC.Base.<> ( "class_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_162 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_162) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_163 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_164 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_165 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_166 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_163
          c1_164 = TreeSitter.Node.nodeStartPoint node_162
        TreeSitter.Node.TSPoint
          r2_165
          c2_166 = TreeSitter.Node.nodeEndPoint node_162
  
  deriving instance GHC.Classes.Eq a_167 => GHC.Classes.Eq (ClassDeclaration a_167)
  
  deriving instance GHC.Classes.Ord a_168 => GHC.Classes.Ord (ClassDeclaration a_168)
  
  deriving instance GHC.Show.Show a_169 => GHC.Show.Show (ClassDeclaration a_169)
  
  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 ClassInterfaceClause a = ClassInterfaceClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (QualifiedName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_170.
        AST.Traversable1.Class.Traversable1 a_170
      )
  
  instance AST.Unmarshal.SymbolMatching ClassInterfaceClause where
    matchedSymbols _ = [178]
    showFailure _ node_171 =
      "expected "
        GHC.Base.<> ( "class_interface_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_171 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_171) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_172 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_173 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_174 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_175 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_172
          c1_173 = TreeSitter.Node.nodeStartPoint node_171
        TreeSitter.Node.TSPoint
          r2_174
          c2_175 = TreeSitter.Node.nodeEndPoint node_171
  
  deriving instance GHC.Classes.Eq a_176 => GHC.Classes.Eq (ClassInterfaceClause a_176)
  
  deriving instance GHC.Classes.Ord a_177 => GHC.Classes.Ord (ClassInterfaceClause a_177)
  
  deriving instance GHC.Show.Show a_178 => GHC.Show.Show (ClassInterfaceClause a_178)
  
  instance AST.Unmarshal.Unmarshal ClassInterfaceClause
  
  instance Data.Foldable.Foldable ClassInterfaceClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassInterfaceClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassInterfaceClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassModifier a = ClassModifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_179.
        AST.Traversable1.Class.Traversable1 a_179
      )
  
  instance AST.Unmarshal.SymbolMatching ClassModifier where
    matchedSymbols _ = [176]
    showFailure _ node_180 =
      "expected "
        GHC.Base.<> ( "class_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_180 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_180) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_181 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_182 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_183 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_184 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_181
          c1_182 = TreeSitter.Node.nodeStartPoint node_180
        TreeSitter.Node.TSPoint
          r2_183
          c2_184 = TreeSitter.Node.nodeEndPoint node_180
  
  deriving instance GHC.Classes.Eq a_185 => GHC.Classes.Eq (ClassModifier a_185)
  
  deriving instance GHC.Classes.Ord a_186 => GHC.Classes.Ord (ClassModifier a_186)
  
  deriving instance GHC.Show.Show a_187 => GHC.Show.Show (ClassModifier a_187)
  
  instance AST.Unmarshal.Unmarshal ClassModifier
  
  instance Data.Foldable.Foldable ClassModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CloneExpression a = CloneExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (PrimaryExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_188.
        AST.Traversable1.Class.Traversable1 a_188
      )
  
  instance AST.Unmarshal.SymbolMatching CloneExpression where
    matchedSymbols _ = [240]
    showFailure _ node_189 =
      "expected "
        GHC.Base.<> ( "clone_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_189 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_189) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_190 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_191 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_192 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_193 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_190
          c1_191 = TreeSitter.Node.nodeStartPoint node_189
        TreeSitter.Node.TSPoint
          r2_192
          c2_193 = TreeSitter.Node.nodeEndPoint node_189
  
  deriving instance GHC.Classes.Eq a_194 => GHC.Classes.Eq (CloneExpression a_194)
  
  deriving instance GHC.Classes.Ord a_195 => GHC.Classes.Ord (CloneExpression a_195)
  
  deriving instance GHC.Show.Show a_196 => GHC.Show.Show (CloneExpression a_196)
  
  instance AST.Unmarshal.Unmarshal CloneExpression
  
  instance Data.Foldable.Foldable CloneExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CloneExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CloneExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ColonBlock a = ColonBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_197.
        AST.Traversable1.Class.Traversable1 a_197
      )
  
  instance AST.Unmarshal.SymbolMatching ColonBlock where
    matchedSymbols _ = [224]
    showFailure _ node_198 =
      "expected "
        GHC.Base.<> ( "colon_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_198 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_198) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_199 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_200 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_201 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_202 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_199
          c1_200 = TreeSitter.Node.nodeStartPoint node_198
        TreeSitter.Node.TSPoint
          r2_201
          c2_202 = TreeSitter.Node.nodeEndPoint node_198
  
  deriving instance GHC.Classes.Eq a_203 => GHC.Classes.Eq (ColonBlock a_203)
  
  deriving instance GHC.Classes.Ord a_204 => GHC.Classes.Ord (ColonBlock a_204)
  
  deriving instance GHC.Show.Show a_205 => GHC.Show.Show (ColonBlock a_205)
  
  instance AST.Unmarshal.Unmarshal ColonBlock
  
  instance Data.Foldable.Foldable ColonBlock where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ColonBlock where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ColonBlock where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data CompoundStatement a = CompoundStatement
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_206.
        AST.Traversable1.Class.Traversable1 a_206
      )
  
  instance AST.Unmarshal.SymbolMatching CompoundStatement where
    matchedSymbols _ = [233]
    showFailure _ node_207 =
      "expected "
        GHC.Base.<> ( "compound_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_207 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_207) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_208 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_209 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_210 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_211 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_208
          c1_209 = TreeSitter.Node.nodeStartPoint node_207
        TreeSitter.Node.TSPoint
          r2_210
          c2_211 = TreeSitter.Node.nodeEndPoint node_207
  
  deriving instance GHC.Classes.Eq a_212 => GHC.Classes.Eq (CompoundStatement a_212)
  
  deriving instance GHC.Classes.Ord a_213 => GHC.Classes.Ord (CompoundStatement a_213)
  
  deriving instance GHC.Show.Show a_214 => GHC.Show.Show (CompoundStatement a_214)
  
  instance AST.Unmarshal.Unmarshal CompoundStatement
  
  instance Data.Foldable.Foldable CompoundStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor CompoundStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable CompoundStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConditionalExpression a = ConditionalExpression
    { ann :: a,
      alternative :: (AST.Parse.Err (Expression a)),
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      condition :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_215.
        AST.Traversable1.Class.Traversable1 a_215
      )
  
  instance AST.Unmarshal.SymbolMatching ConditionalExpression where
    matchedSymbols _ = [252]
    showFailure _ node_216 =
      "expected "
        GHC.Base.<> ( "conditional_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_216 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_216) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_217 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_218 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_219 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_220 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_217
          c1_218 = TreeSitter.Node.nodeStartPoint node_216
        TreeSitter.Node.TSPoint
          r2_219
          c2_220 = TreeSitter.Node.nodeEndPoint node_216
  
  deriving instance GHC.Classes.Eq a_221 => GHC.Classes.Eq (ConditionalExpression a_221)
  
  deriving instance GHC.Classes.Ord a_222 => GHC.Classes.Ord (ConditionalExpression a_222)
  
  deriving instance GHC.Show.Show a_223 => GHC.Show.Show (ConditionalExpression a_223)
  
  instance AST.Unmarshal.Unmarshal ConditionalExpression
  
  instance Data.Foldable.Foldable ConditionalExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConditionalExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConditionalExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConstDeclaration a = ConstDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ConstElement GHC.Generics.:+: VisibilityModifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_224.
        AST.Traversable1.Class.Traversable1 a_224
      )
  
  instance AST.Unmarshal.SymbolMatching ConstDeclaration where
    matchedSymbols _ = [180]
    showFailure _ node_225 =
      "expected "
        GHC.Base.<> ( "const_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_225 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_225) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_226 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_227 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_228 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_229 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_226
          c1_227 = TreeSitter.Node.nodeStartPoint node_225
        TreeSitter.Node.TSPoint
          r2_228
          c2_229 = TreeSitter.Node.nodeEndPoint node_225
  
  deriving instance GHC.Classes.Eq a_230 => GHC.Classes.Eq (ConstDeclaration a_230)
  
  deriving instance GHC.Classes.Ord a_231 => GHC.Classes.Ord (ConstDeclaration a_231)
  
  deriving instance GHC.Show.Show a_232 => GHC.Show.Show (ConstDeclaration a_232)
  
  instance AST.Unmarshal.Unmarshal ConstDeclaration
  
  instance Data.Foldable.Foldable ConstDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConstDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConstDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConstElement a = ConstElement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Name) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_233.
        AST.Traversable1.Class.Traversable1 a_233
      )
  
  instance AST.Unmarshal.SymbolMatching ConstElement where
    matchedSymbols _ = [202]
    showFailure _ node_234 =
      "expected "
        GHC.Base.<> ( "const_element"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_234 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_234) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_235 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_236 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_237 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_238 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_235
          c1_236 = TreeSitter.Node.nodeStartPoint node_234
        TreeSitter.Node.TSPoint
          r2_237
          c2_238 = TreeSitter.Node.nodeEndPoint node_234
  
  deriving instance GHC.Classes.Eq a_239 => GHC.Classes.Eq (ConstElement a_239)
  
  deriving instance GHC.Classes.Ord a_240 => GHC.Classes.Ord (ConstElement a_240)
  
  deriving instance GHC.Show.Show a_241 => GHC.Show.Show (ConstElement a_241)
  
  instance AST.Unmarshal.Unmarshal ConstElement
  
  instance Data.Foldable.Foldable ConstElement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConstElement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConstElement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ContinueStatement a = ContinueStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_242.
        AST.Traversable1.Class.Traversable1 a_242
      )
  
  instance AST.Unmarshal.SymbolMatching ContinueStatement where
    matchedSymbols _ = [212]
    showFailure _ node_243 =
      "expected "
        GHC.Base.<> ( "continue_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_243 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_243) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_244 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_245 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_246 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_247 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_244
          c1_245 = TreeSitter.Node.nodeStartPoint node_243
        TreeSitter.Node.TSPoint
          r2_246
          c2_247 = TreeSitter.Node.nodeEndPoint node_243
  
  deriving instance GHC.Classes.Eq a_248 => GHC.Classes.Eq (ContinueStatement a_248)
  
  deriving instance GHC.Classes.Ord a_249 => GHC.Classes.Ord (ContinueStatement a_249)
  
  deriving instance GHC.Show.Show a_250 => GHC.Show.Show (ContinueStatement a_250)
  
  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 DeclarationList a = DeclarationList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((ConstDeclaration GHC.Generics.:+: MethodDeclaration GHC.Generics.:+: PropertyDeclaration GHC.Generics.:+: UseDeclaration) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_251.
        AST.Traversable1.Class.Traversable1 a_251
      )
  
  instance AST.Unmarshal.SymbolMatching DeclarationList where
    matchedSymbols _ = [175]
    showFailure _ node_252 =
      "expected "
        GHC.Base.<> ( "declaration_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_252 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_252) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_253 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_254 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_255 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_256 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_253
          c1_254 = TreeSitter.Node.nodeStartPoint node_252
        TreeSitter.Node.TSPoint
          r2_255
          c2_256 = TreeSitter.Node.nodeEndPoint node_252
  
  deriving instance GHC.Classes.Eq a_257 => GHC.Classes.Eq (DeclarationList a_257)
  
  deriving instance GHC.Classes.Ord a_258 => GHC.Classes.Ord (DeclarationList a_258)
  
  deriving instance GHC.Show.Show a_259 => GHC.Show.Show (DeclarationList a_259)
  
  instance AST.Unmarshal.Unmarshal DeclarationList
  
  instance Data.Foldable.Foldable DeclarationList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DeclarationList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DeclarationList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DeclareDirective a = DeclareDirective
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Literal a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_260.
        AST.Traversable1.Class.Traversable1 a_260
      )
  
  instance AST.Unmarshal.SymbolMatching DeclareDirective where
    matchedSymbols _ = [206]
    showFailure _ node_261 =
      "expected "
        GHC.Base.<> ( "declare_directive"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_261 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_261) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_262 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_263 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_264 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_265 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_262
          c1_263 = TreeSitter.Node.nodeStartPoint node_261
        TreeSitter.Node.TSPoint
          r2_264
          c2_265 = TreeSitter.Node.nodeEndPoint node_261
  
  deriving instance GHC.Classes.Eq a_266 => GHC.Classes.Eq (DeclareDirective a_266)
  
  deriving instance GHC.Classes.Ord a_267 => GHC.Classes.Ord (DeclareDirective a_267)
  
  deriving instance GHC.Show.Show a_268 => GHC.Show.Show (DeclareDirective a_268)
  
  instance AST.Unmarshal.Unmarshal DeclareDirective
  
  instance Data.Foldable.Foldable DeclareDirective where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DeclareDirective where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DeclareDirective where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DeclareStatement a = DeclareStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Statement GHC.Generics.:+: DeclareDirective) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_269.
        AST.Traversable1.Class.Traversable1 a_269
      )
  
  instance AST.Unmarshal.SymbolMatching DeclareStatement where
    matchedSymbols _ = [205]
    showFailure _ node_270 =
      "expected "
        GHC.Base.<> ( "declare_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_270 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_270) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_271 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_272 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_273 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_274 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_271
          c1_272 = TreeSitter.Node.nodeStartPoint node_270
        TreeSitter.Node.TSPoint
          r2_273
          c2_274 = TreeSitter.Node.nodeEndPoint node_270
  
  deriving instance GHC.Classes.Eq a_275 => GHC.Classes.Eq (DeclareStatement a_275)
  
  deriving instance GHC.Classes.Ord a_276 => GHC.Classes.Ord (DeclareStatement a_276)
  
  deriving instance GHC.Show.Show a_277 => GHC.Show.Show (DeclareStatement a_277)
  
  instance AST.Unmarshal.Unmarshal DeclareStatement
  
  instance Data.Foldable.Foldable DeclareStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DeclareStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DeclareStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DefaultStatement a = DefaultStatement
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Statement a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_278.
        AST.Traversable1.Class.Traversable1 a_278
      )
  
  instance AST.Unmarshal.SymbolMatching DefaultStatement where
    matchedSymbols _ = [232]
    showFailure _ node_279 =
      "expected "
        GHC.Base.<> ( "default_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_279 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_279) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_280 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_281 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_282 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_283 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_280
          c1_281 = TreeSitter.Node.nodeStartPoint node_279
        TreeSitter.Node.TSPoint
          r2_282
          c2_283 = TreeSitter.Node.nodeEndPoint node_279
  
  deriving instance GHC.Classes.Eq a_284 => GHC.Classes.Eq (DefaultStatement a_284)
  
  deriving instance GHC.Classes.Ord a_285 => GHC.Classes.Ord (DefaultStatement a_285)
  
  deriving instance GHC.Show.Show a_286 => GHC.Show.Show (DefaultStatement a_286)
  
  instance AST.Unmarshal.Unmarshal DefaultStatement
  
  instance Data.Foldable.Foldable DefaultStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DefaultStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DefaultStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DoStatement a = DoStatement
    { 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_287.
        AST.Traversable1.Class.Traversable1 a_287
      )
  
  instance AST.Unmarshal.SymbolMatching DoStatement where
    matchedSymbols _ = [217]
    showFailure _ node_288 =
      "expected "
        GHC.Base.<> ( "do_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_288 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_288) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_289 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_290 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_291 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_292 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_289
          c1_290 = TreeSitter.Node.nodeStartPoint node_288
        TreeSitter.Node.TSPoint
          r2_291
          c2_292 = TreeSitter.Node.nodeEndPoint node_288
  
  deriving instance GHC.Classes.Eq a_293 => GHC.Classes.Eq (DoStatement a_293)
  
  deriving instance GHC.Classes.Ord a_294 => GHC.Classes.Ord (DoStatement a_294)
  
  deriving instance GHC.Show.Show a_295 => GHC.Show.Show (DoStatement a_295)
  
  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 DynamicVariableName a = DynamicVariableName
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_296.
        AST.Traversable1.Class.Traversable1 a_296
      )
  
  instance AST.Unmarshal.SymbolMatching DynamicVariableName where
    matchedSymbols _ = [268]
    showFailure _ node_297 =
      "expected "
        GHC.Base.<> ( "dynamic_variable_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_297 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_297) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_298 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_299 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_300 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_301 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_298
          c1_299 = TreeSitter.Node.nodeStartPoint node_297
        TreeSitter.Node.TSPoint
          r2_300
          c2_301 = TreeSitter.Node.nodeEndPoint node_297
  
  deriving instance GHC.Classes.Eq a_302 => GHC.Classes.Eq (DynamicVariableName a_302)
  
  deriving instance GHC.Classes.Ord a_303 => GHC.Classes.Ord (DynamicVariableName a_303)
  
  deriving instance GHC.Show.Show a_304 => GHC.Show.Show (DynamicVariableName a_304)
  
  instance AST.Unmarshal.Unmarshal DynamicVariableName
  
  instance Data.Foldable.Foldable DynamicVariableName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DynamicVariableName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DynamicVariableName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EchoStatement a = EchoStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_305.
        AST.Traversable1.Class.Traversable1 a_305
      )
  
  instance AST.Unmarshal.SymbolMatching EchoStatement where
    matchedSymbols _ = [203]
    showFailure _ node_306 =
      "expected "
        GHC.Base.<> ( "echo_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_306 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_306) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_307 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_308 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_309 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_310 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_307
          c1_308 = TreeSitter.Node.nodeStartPoint node_306
        TreeSitter.Node.TSPoint
          r2_309
          c2_310 = TreeSitter.Node.nodeEndPoint node_306
  
  deriving instance GHC.Classes.Eq a_311 => GHC.Classes.Eq (EchoStatement a_311)
  
  deriving instance GHC.Classes.Ord a_312 => GHC.Classes.Ord (EchoStatement a_312)
  
  deriving instance GHC.Show.Show a_313 => GHC.Show.Show (EchoStatement a_313)
  
  instance AST.Unmarshal.Unmarshal EchoStatement
  
  instance Data.Foldable.Foldable EchoStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EchoStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EchoStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElseClause a = ElseClause
    { ann :: a,
      body :: (AST.Parse.Err ((Statement GHC.Generics.:+: ColonBlock) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_314.
        AST.Traversable1.Class.Traversable1 a_314
      )
  
  instance AST.Unmarshal.SymbolMatching ElseClause where
    matchedSymbols _ = [226, 228]
    showFailure _ node_315 =
      "expected "
        GHC.Base.<> ( "else_clause, else_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_315 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_315) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_316 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_317 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_318 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_319 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_316
          c1_317 = TreeSitter.Node.nodeStartPoint node_315
        TreeSitter.Node.TSPoint
          r2_318
          c2_319 = TreeSitter.Node.nodeEndPoint node_315
  
  deriving instance GHC.Classes.Eq a_320 => GHC.Classes.Eq (ElseClause a_320)
  
  deriving instance GHC.Classes.Ord a_321 => GHC.Classes.Ord (ElseClause a_321)
  
  deriving instance GHC.Show.Show a_322 => GHC.Show.Show (ElseClause a_322)
  
  instance AST.Unmarshal.Unmarshal ElseClause
  
  instance Data.Foldable.Foldable ElseClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElseClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElseClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElseIfClause a = ElseIfClause
    { ann :: a,
      body :: (AST.Parse.Err ((Statement GHC.Generics.:+: ColonBlock) a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_323.
        AST.Traversable1.Class.Traversable1 a_323
      )
  
  instance AST.Unmarshal.SymbolMatching ElseIfClause where
    matchedSymbols _ = [225, 227]
    showFailure _ node_324 =
      "expected "
        GHC.Base.<> ( "else_if_clause, else_if_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_324 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_324) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_325 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_326 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_327 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_328 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_325
          c1_326 = TreeSitter.Node.nodeStartPoint node_324
        TreeSitter.Node.TSPoint
          r2_327
          c2_328 = TreeSitter.Node.nodeEndPoint node_324
  
  deriving instance GHC.Classes.Eq a_329 => GHC.Classes.Eq (ElseIfClause a_329)
  
  deriving instance GHC.Classes.Ord a_330 => GHC.Classes.Ord (ElseIfClause a_330)
  
  deriving instance GHC.Show.Show a_331 => GHC.Show.Show (ElseIfClause a_331)
  
  instance AST.Unmarshal.Unmarshal ElseIfClause
  
  instance Data.Foldable.Foldable ElseIfClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElseIfClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElseIfClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EmptyStatement a = EmptyStatement {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_332.
        AST.Traversable1.Class.Traversable1 a_332
      )
  
  instance AST.Unmarshal.SymbolMatching EmptyStatement where
    matchedSymbols _ = [157]
    showFailure _ node_333 =
      "expected "
        GHC.Base.<> ( "empty_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_333 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_333) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_334 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_335 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_336 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_337 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_334
          c1_335 = TreeSitter.Node.nodeStartPoint node_333
        TreeSitter.Node.TSPoint
          r2_336
          c2_337 = TreeSitter.Node.nodeEndPoint node_333
  
  deriving instance GHC.Classes.Eq a_338 => GHC.Classes.Eq (EmptyStatement a_338)
  
  deriving instance GHC.Classes.Ord a_339 => GHC.Classes.Ord (EmptyStatement a_339)
  
  deriving instance GHC.Show.Show a_340 => GHC.Show.Show (EmptyStatement a_340)
  
  instance AST.Unmarshal.Unmarshal EmptyStatement
  
  instance Data.Foldable.Foldable EmptyStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EmptyStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EmptyStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExponentiationExpression a = ExponentiationExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((PrimaryExpression GHC.Generics.:+: CloneExpression GHC.Generics.:+: ExponentiationExpression) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_341.
        AST.Traversable1.Class.Traversable1 a_341
      )
  
  instance AST.Unmarshal.SymbolMatching ExponentiationExpression where
    matchedSymbols _ = [239]
    showFailure _ node_342 =
      "expected "
        GHC.Base.<> ( "exponentiation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_342 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_342) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_343 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_344 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_345 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_346 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_343
          c1_344 = TreeSitter.Node.nodeStartPoint node_342
        TreeSitter.Node.TSPoint
          r2_345
          c2_346 = TreeSitter.Node.nodeEndPoint node_342
  
  deriving instance GHC.Classes.Eq a_347 => GHC.Classes.Eq (ExponentiationExpression a_347)
  
  deriving instance GHC.Classes.Ord a_348 => GHC.Classes.Ord (ExponentiationExpression a_348)
  
  deriving instance GHC.Show.Show a_349 => GHC.Show.Show (ExponentiationExpression a_349)
  
  instance AST.Unmarshal.Unmarshal ExponentiationExpression
  
  instance Data.Foldable.Foldable ExponentiationExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExponentiationExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExponentiationExpression 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_350.
        AST.Traversable1.Class.Traversable1 a_350
      )
  
  instance AST.Unmarshal.SymbolMatching ExpressionStatement where
    matchedSymbols _ = [235]
    showFailure _ node_351 =
      "expected "
        GHC.Base.<> ( "expression_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_351 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_351) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_352 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_353 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_354 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_355 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_352
          c1_353 = TreeSitter.Node.nodeStartPoint node_351
        TreeSitter.Node.TSPoint
          r2_354
          c2_355 = TreeSitter.Node.nodeEndPoint node_351
  
  deriving instance GHC.Classes.Eq a_356 => GHC.Classes.Eq (ExpressionStatement a_356)
  
  deriving instance GHC.Classes.Ord a_357 => GHC.Classes.Ord (ExpressionStatement a_357)
  
  deriving instance GHC.Show.Show a_358 => GHC.Show.Show (ExpressionStatement a_358)
  
  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 FinallyClause a = FinallyClause
    { ann :: a,
      body :: (AST.Parse.Err (CompoundStatement a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_359.
        AST.Traversable1.Class.Traversable1 a_359
      )
  
  instance AST.Unmarshal.SymbolMatching FinallyClause where
    matchedSymbols _ = [209]
    showFailure _ node_360 =
      "expected "
        GHC.Base.<> ( "finally_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_360 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_360) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_361 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_362 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_363 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_364 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_361
          c1_362 = TreeSitter.Node.nodeStartPoint node_360
        TreeSitter.Node.TSPoint
          r2_363
          c2_364 = TreeSitter.Node.nodeEndPoint node_360
  
  deriving instance GHC.Classes.Eq a_365 => GHC.Classes.Eq (FinallyClause a_365)
  
  deriving instance GHC.Classes.Ord a_366 => GHC.Classes.Ord (FinallyClause a_366)
  
  deriving instance GHC.Show.Show a_367 => GHC.Show.Show (FinallyClause a_367)
  
  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 ForStatement a = ForStatement
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: Statement GHC.Generics.:+: SequenceExpression) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_368.
        AST.Traversable1.Class.Traversable1 a_368
      )
  
  instance AST.Unmarshal.SymbolMatching ForStatement where
    matchedSymbols _ = [218]
    showFailure _ node_369 =
      "expected "
        GHC.Base.<> ( "for_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_369 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_369) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_370 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_371 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_372 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_373 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_370
          c1_371 = TreeSitter.Node.nodeStartPoint node_369
        TreeSitter.Node.TSPoint
          r2_372
          c2_373 = TreeSitter.Node.nodeEndPoint node_369
  
  deriving instance GHC.Classes.Eq a_374 => GHC.Classes.Eq (ForStatement a_374)
  
  deriving instance GHC.Classes.Ord a_375 => GHC.Classes.Ord (ForStatement a_375)
  
  deriving instance GHC.Show.Show a_376 => GHC.Show.Show (ForStatement a_376)
  
  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 ForeachStatement a = ForeachStatement
    { ann :: a,
      body :: (GHC.Maybe.Maybe (AST.Parse.Err ((Statement GHC.Generics.:+: ColonBlock) a))),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: ListLiteral GHC.Generics.:+: Pair) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_377.
        AST.Traversable1.Class.Traversable1 a_377
      )
  
  instance AST.Unmarshal.SymbolMatching ForeachStatement where
    matchedSymbols _ = [221]
    showFailure _ node_378 =
      "expected "
        GHC.Base.<> ( "foreach_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_378 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_378) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_379 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_380 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_381 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_382 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_379
          c1_380 = TreeSitter.Node.nodeStartPoint node_378
        TreeSitter.Node.TSPoint
          r2_381
          c2_382 = TreeSitter.Node.nodeEndPoint node_378
  
  deriving instance GHC.Classes.Eq a_383 => GHC.Classes.Eq (ForeachStatement a_383)
  
  deriving instance GHC.Classes.Ord a_384 => GHC.Classes.Ord (ForeachStatement a_384)
  
  deriving instance GHC.Show.Show a_385 => GHC.Show.Show (ForeachStatement a_385)
  
  instance AST.Unmarshal.Unmarshal ForeachStatement
  
  instance Data.Foldable.Foldable ForeachStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ForeachStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ForeachStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FormalParameters a = FormalParameters
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((SimpleParameter GHC.Generics.:+: VariadicParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_386.
        AST.Traversable1.Class.Traversable1 a_386
      )
  
  instance AST.Unmarshal.SymbolMatching FormalParameters where
    matchedSymbols _ = [194]
    showFailure _ node_387 =
      "expected "
        GHC.Base.<> ( "formal_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_387 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_387) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_388 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_389 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_390 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_391 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_388
          c1_389 = TreeSitter.Node.nodeStartPoint node_387
        TreeSitter.Node.TSPoint
          r2_390
          c2_391 = TreeSitter.Node.nodeEndPoint node_387
  
  deriving instance GHC.Classes.Eq a_392 => GHC.Classes.Eq (FormalParameters a_392)
  
  deriving instance GHC.Classes.Ord a_393 => GHC.Classes.Ord (FormalParameters a_393)
  
  deriving instance GHC.Show.Show a_394 => GHC.Show.Show (FormalParameters a_394)
  
  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 FunctionCallExpression a = FunctionCallExpression
    { ann :: a,
      function :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)),
      arguments :: (AST.Parse.Err (Arguments a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_395.
        AST.Traversable1.Class.Traversable1 a_395
      )
  
  instance AST.Unmarshal.SymbolMatching FunctionCallExpression where
    matchedSymbols _ = [257]
    showFailure _ node_396 =
      "expected "
        GHC.Base.<> ( "function_call_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_396 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_396) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_397 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_398 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_399 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_400 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_397
          c1_398 = TreeSitter.Node.nodeStartPoint node_396
        TreeSitter.Node.TSPoint
          r2_399
          c2_400 = TreeSitter.Node.nodeEndPoint node_396
  
  deriving instance GHC.Classes.Eq a_401 => GHC.Classes.Eq (FunctionCallExpression a_401)
  
  deriving instance GHC.Classes.Ord a_402 => GHC.Classes.Ord (FunctionCallExpression a_402)
  
  deriving instance GHC.Show.Show a_403 => GHC.Show.Show (FunctionCallExpression a_403)
  
  instance AST.Unmarshal.Unmarshal FunctionCallExpression
  
  instance Data.Foldable.Foldable FunctionCallExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FunctionCallExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FunctionCallExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FunctionDefinition a = FunctionDefinition
    { ann :: a,
      returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a))),
      body :: (AST.Parse.Err (CompoundStatement a)),
      name :: (AST.Parse.Err (Name a)),
      parameters :: (AST.Parse.Err (FormalParameters a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_404.
        AST.Traversable1.Class.Traversable1 a_404
      )
  
  instance AST.Unmarshal.SymbolMatching FunctionDefinition where
    matchedSymbols _ = [192]
    showFailure _ node_405 =
      "expected "
        GHC.Base.<> ( "function_definition"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_405 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_405) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_406 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_407 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_408 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_409 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_406
          c1_407 = TreeSitter.Node.nodeStartPoint node_405
        TreeSitter.Node.TSPoint
          r2_408
          c2_409 = TreeSitter.Node.nodeEndPoint node_405
  
  deriving instance GHC.Classes.Eq a_410 => GHC.Classes.Eq (FunctionDefinition a_410)
  
  deriving instance GHC.Classes.Ord a_411 => GHC.Classes.Ord (FunctionDefinition a_411)
  
  deriving instance GHC.Show.Show a_412 => GHC.Show.Show (FunctionDefinition a_412)
  
  instance AST.Unmarshal.Unmarshal FunctionDefinition
  
  instance Data.Foldable.Foldable FunctionDefinition where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FunctionDefinition where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FunctionDefinition where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FunctionStaticDeclaration a = FunctionStaticDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (StaticVariableDeclaration a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_413.
        AST.Traversable1.Class.Traversable1 a_413
      )
  
  instance AST.Unmarshal.SymbolMatching FunctionStaticDeclaration where
    matchedSymbols _ = [158]
    showFailure _ node_414 =
      "expected "
        GHC.Base.<> ( "function_static_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_414 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_414) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_415 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_416 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_417 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_418 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_415
          c1_416 = TreeSitter.Node.nodeStartPoint node_414
        TreeSitter.Node.TSPoint
          r2_417
          c2_418 = TreeSitter.Node.nodeEndPoint node_414
  
  deriving instance GHC.Classes.Eq a_419 => GHC.Classes.Eq (FunctionStaticDeclaration a_419)
  
  deriving instance GHC.Classes.Ord a_420 => GHC.Classes.Ord (FunctionStaticDeclaration a_420)
  
  deriving instance GHC.Show.Show a_421 => GHC.Show.Show (FunctionStaticDeclaration a_421)
  
  instance AST.Unmarshal.Unmarshal FunctionStaticDeclaration
  
  instance Data.Foldable.Foldable FunctionStaticDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FunctionStaticDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FunctionStaticDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data GlobalDeclaration a = GlobalDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((DynamicVariableName GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_422.
        AST.Traversable1.Class.Traversable1 a_422
      )
  
  instance AST.Unmarshal.SymbolMatching GlobalDeclaration where
    matchedSymbols _ = [160]
    showFailure _ node_423 =
      "expected "
        GHC.Base.<> ( "global_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_423 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_423) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_424 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_425 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_426 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_427 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_424
          c1_425 = TreeSitter.Node.nodeStartPoint node_423
        TreeSitter.Node.TSPoint
          r2_426
          c2_427 = TreeSitter.Node.nodeEndPoint node_423
  
  deriving instance GHC.Classes.Eq a_428 => GHC.Classes.Eq (GlobalDeclaration a_428)
  
  deriving instance GHC.Classes.Ord a_429 => GHC.Classes.Ord (GlobalDeclaration a_429)
  
  deriving instance GHC.Show.Show a_430 => GHC.Show.Show (GlobalDeclaration a_430)
  
  instance AST.Unmarshal.Unmarshal GlobalDeclaration
  
  instance Data.Foldable.Foldable GlobalDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GlobalDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GlobalDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data GotoStatement a = GotoStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Name a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_431.
        AST.Traversable1.Class.Traversable1 a_431
      )
  
  instance AST.Unmarshal.SymbolMatching GotoStatement where
    matchedSymbols _ = [211]
    showFailure _ node_432 =
      "expected "
        GHC.Base.<> ( "goto_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_432 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_432) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_433 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_434 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_435 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_436 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_433
          c1_434 = TreeSitter.Node.nodeStartPoint node_432
        TreeSitter.Node.TSPoint
          r2_435
          c2_436 = TreeSitter.Node.nodeEndPoint node_432
  
  deriving instance GHC.Classes.Eq a_437 => GHC.Classes.Eq (GotoStatement a_437)
  
  deriving instance GHC.Classes.Ord a_438 => GHC.Classes.Ord (GotoStatement a_438)
  
  deriving instance GHC.Show.Show a_439 => GHC.Show.Show (GotoStatement a_439)
  
  instance AST.Unmarshal.Unmarshal GotoStatement
  
  instance Data.Foldable.Foldable GotoStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GotoStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GotoStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfStatement a = IfStatement
    { ann :: a,
      alternative :: ([AST.Parse.Err ((ElseClause GHC.Generics.:+: ElseIfClause) a)]),
      body :: (AST.Parse.Err ((Statement GHC.Generics.:+: ColonBlock) a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_440.
        AST.Traversable1.Class.Traversable1 a_440
      )
  
  instance AST.Unmarshal.SymbolMatching IfStatement where
    matchedSymbols _ = [223]
    showFailure _ node_441 =
      "expected "
        GHC.Base.<> ( "if_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_441 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_441) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_442 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_443 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_444 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_445 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_442
          c1_443 = TreeSitter.Node.nodeStartPoint node_441
        TreeSitter.Node.TSPoint
          r2_444
          c2_445 = TreeSitter.Node.nodeEndPoint node_441
  
  deriving instance GHC.Classes.Eq a_446 => GHC.Classes.Eq (IfStatement a_446)
  
  deriving instance GHC.Classes.Ord a_447 => GHC.Classes.Ord (IfStatement a_447)
  
  deriving instance GHC.Show.Show a_448 => GHC.Show.Show (IfStatement a_448)
  
  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 IncludeExpression a = IncludeExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_449.
        AST.Traversable1.Class.Traversable1 a_449
      )
  
  instance AST.Unmarshal.SymbolMatching IncludeExpression where
    matchedSymbols _ = [273]
    showFailure _ node_450 =
      "expected "
        GHC.Base.<> ( "include_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_450 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_450) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_451 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_452 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_453 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_454 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_451
          c1_452 = TreeSitter.Node.nodeStartPoint node_450
        TreeSitter.Node.TSPoint
          r2_453
          c2_454 = TreeSitter.Node.nodeEndPoint node_450
  
  deriving instance GHC.Classes.Eq a_455 => GHC.Classes.Eq (IncludeExpression a_455)
  
  deriving instance GHC.Classes.Ord a_456 => GHC.Classes.Ord (IncludeExpression a_456)
  
  deriving instance GHC.Show.Show a_457 => GHC.Show.Show (IncludeExpression a_457)
  
  instance AST.Unmarshal.Unmarshal IncludeExpression
  
  instance Data.Foldable.Foldable IncludeExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IncludeExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IncludeExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IncludeOnceExpression a = IncludeOnceExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_458.
        AST.Traversable1.Class.Traversable1 a_458
      )
  
  instance AST.Unmarshal.SymbolMatching IncludeOnceExpression where
    matchedSymbols _ = [274]
    showFailure _ node_459 =
      "expected "
        GHC.Base.<> ( "include_once_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_459 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_459) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_460 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_461 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_462 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_463 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_460
          c1_461 = TreeSitter.Node.nodeStartPoint node_459
        TreeSitter.Node.TSPoint
          r2_462
          c2_463 = TreeSitter.Node.nodeEndPoint node_459
  
  deriving instance GHC.Classes.Eq a_464 => GHC.Classes.Eq (IncludeOnceExpression a_464)
  
  deriving instance GHC.Classes.Ord a_465 => GHC.Classes.Ord (IncludeOnceExpression a_465)
  
  deriving instance GHC.Show.Show a_466 => GHC.Show.Show (IncludeOnceExpression a_466)
  
  instance AST.Unmarshal.Unmarshal IncludeOnceExpression
  
  instance Data.Foldable.Foldable IncludeOnceExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IncludeOnceExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IncludeOnceExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InterfaceBaseClause a = InterfaceBaseClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (QualifiedName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_467.
        AST.Traversable1.Class.Traversable1 a_467
      )
  
  instance AST.Unmarshal.SymbolMatching InterfaceBaseClause where
    matchedSymbols _ = [173]
    showFailure _ node_468 =
      "expected "
        GHC.Base.<> ( "interface_base_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_468 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_468) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_469 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_470 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_471 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_472 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_469
          c1_470 = TreeSitter.Node.nodeStartPoint node_468
        TreeSitter.Node.TSPoint
          r2_471
          c2_472 = TreeSitter.Node.nodeEndPoint node_468
  
  deriving instance GHC.Classes.Eq a_473 => GHC.Classes.Eq (InterfaceBaseClause a_473)
  
  deriving instance GHC.Classes.Ord a_474 => GHC.Classes.Ord (InterfaceBaseClause a_474)
  
  deriving instance GHC.Show.Show a_475 => GHC.Show.Show (InterfaceBaseClause a_475)
  
  instance AST.Unmarshal.Unmarshal InterfaceBaseClause
  
  instance Data.Foldable.Foldable InterfaceBaseClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InterfaceBaseClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InterfaceBaseClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data InterfaceDeclaration a = InterfaceDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (DeclarationList a)),
      name :: (AST.Parse.Err (Name a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (InterfaceBaseClause a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_476.
        AST.Traversable1.Class.Traversable1 a_476
      )
  
  instance AST.Unmarshal.SymbolMatching InterfaceDeclaration where
    matchedSymbols _ = [172]
    showFailure _ node_477 =
      "expected "
        GHC.Base.<> ( "interface_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_477 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_477) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_478 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_479 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_480 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_481 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_478
          c1_479 = TreeSitter.Node.nodeStartPoint node_477
        TreeSitter.Node.TSPoint
          r2_480
          c2_481 = TreeSitter.Node.nodeEndPoint node_477
  
  deriving instance GHC.Classes.Eq a_482 => GHC.Classes.Eq (InterfaceDeclaration a_482)
  
  deriving instance GHC.Classes.Ord a_483 => GHC.Classes.Ord (InterfaceDeclaration a_483)
  
  deriving instance GHC.Show.Show a_484 => GHC.Show.Show (InterfaceDeclaration a_484)
  
  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 ListLiteral a = ListLiteral
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: ListLiteral GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_485.
        AST.Traversable1.Class.Traversable1 a_485
      )
  
  instance AST.Unmarshal.SymbolMatching ListLiteral where
    matchedSymbols _ = [256]
    showFailure _ node_486 =
      "expected "
        GHC.Base.<> ( "list_literal"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_486 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_486) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_487 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_488 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_489 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_490 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_487
          c1_488 = TreeSitter.Node.nodeStartPoint node_486
        TreeSitter.Node.TSPoint
          r2_489
          c2_490 = TreeSitter.Node.nodeEndPoint node_486
  
  deriving instance GHC.Classes.Eq a_491 => GHC.Classes.Eq (ListLiteral a_491)
  
  deriving instance GHC.Classes.Ord a_492 => GHC.Classes.Ord (ListLiteral a_492)
  
  deriving instance GHC.Show.Show a_493 => GHC.Show.Show (ListLiteral a_493)
  
  instance AST.Unmarshal.Unmarshal ListLiteral
  
  instance Data.Foldable.Foldable ListLiteral where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ListLiteral where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ListLiteral where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MemberAccessExpression a = MemberAccessExpression
    { ann :: a,
      name :: (AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: Name GHC.Generics.:+: VariableName) a)),
      object :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_494.
        AST.Traversable1.Class.Traversable1 a_494
      )
  
  instance AST.Unmarshal.SymbolMatching MemberAccessExpression where
    matchedSymbols _ = [254]
    showFailure _ node_495 =
      "expected "
        GHC.Base.<> ( "member_access_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_495 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_495) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_496 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_497 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_498 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_499 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_496
          c1_497 = TreeSitter.Node.nodeStartPoint node_495
        TreeSitter.Node.TSPoint
          r2_498
          c2_499 = TreeSitter.Node.nodeEndPoint node_495
  
  deriving instance GHC.Classes.Eq a_500 => GHC.Classes.Eq (MemberAccessExpression a_500)
  
  deriving instance GHC.Classes.Ord a_501 => GHC.Classes.Ord (MemberAccessExpression a_501)
  
  deriving instance GHC.Show.Show a_502 => GHC.Show.Show (MemberAccessExpression a_502)
  
  instance AST.Unmarshal.Unmarshal MemberAccessExpression
  
  instance Data.Foldable.Foldable MemberAccessExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MemberAccessExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MemberAccessExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MemberCallExpression a = MemberCallExpression
    { ann :: a,
      arguments :: (AST.Parse.Err (Arguments a)),
      name :: (AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: Name GHC.Generics.:+: VariableName) a)),
      object :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_503.
        AST.Traversable1.Class.Traversable1 a_503
      )
  
  instance AST.Unmarshal.SymbolMatching MemberCallExpression where
    matchedSymbols _ = [262]
    showFailure _ node_504 =
      "expected "
        GHC.Base.<> ( "member_call_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_504 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_504) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_505 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_506 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_507 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_508 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_505
          c1_506 = TreeSitter.Node.nodeStartPoint node_504
        TreeSitter.Node.TSPoint
          r2_507
          c2_508 = TreeSitter.Node.nodeEndPoint node_504
  
  deriving instance GHC.Classes.Eq a_509 => GHC.Classes.Eq (MemberCallExpression a_509)
  
  deriving instance GHC.Classes.Ord a_510 => GHC.Classes.Ord (MemberCallExpression a_510)
  
  deriving instance GHC.Show.Show a_511 => GHC.Show.Show (MemberCallExpression a_511)
  
  instance AST.Unmarshal.Unmarshal MemberCallExpression
  
  instance Data.Foldable.Foldable MemberCallExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MemberCallExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MemberCallExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodDeclaration a = MethodDeclaration
    { ann :: a,
      returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a))),
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (CompoundStatement a))),
      name :: (AST.Parse.Err (Name a)),
      parameters :: (AST.Parse.Err (FormalParameters a)),
      extraChildren :: ([AST.Parse.Err ((ClassModifier GHC.Generics.:+: StaticModifier GHC.Generics.:+: VarModifier GHC.Generics.:+: VisibilityModifier) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_512.
        AST.Traversable1.Class.Traversable1 a_512
      )
  
  instance AST.Unmarshal.SymbolMatching MethodDeclaration where
    matchedSymbols _ = [185]
    showFailure _ node_513 =
      "expected "
        GHC.Base.<> ( "method_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_513 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_513) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_514 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_515 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_516 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_517 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_514
          c1_515 = TreeSitter.Node.nodeStartPoint node_513
        TreeSitter.Node.TSPoint
          r2_516
          c2_517 = TreeSitter.Node.nodeEndPoint node_513
  
  deriving instance GHC.Classes.Eq a_518 => GHC.Classes.Eq (MethodDeclaration a_518)
  
  deriving instance GHC.Classes.Ord a_519 => GHC.Classes.Ord (MethodDeclaration a_519)
  
  deriving instance GHC.Show.Show a_520 => GHC.Show.Show (MethodDeclaration a_520)
  
  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 Name a = Name {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_521.
        AST.Traversable1.Class.Traversable1 a_521
      )
  
  instance AST.Unmarshal.SymbolMatching Name where
    matchedSymbols _ = [1, 277]
    showFailure _ node_522 =
      "expected "
        GHC.Base.<> ( "name, name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_522 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_522) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_523 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_524 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_525 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_526 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_523
          c1_524 = TreeSitter.Node.nodeStartPoint node_522
        TreeSitter.Node.TSPoint
          r2_525
          c2_526 = TreeSitter.Node.nodeEndPoint node_522
  
  deriving instance GHC.Classes.Eq a_527 => GHC.Classes.Eq (Name a_527)
  
  deriving instance GHC.Classes.Ord a_528 => GHC.Classes.Ord (Name a_528)
  
  deriving instance GHC.Show.Show a_529 => GHC.Show.Show (Name a_529)
  
  instance AST.Unmarshal.Unmarshal Name
  
  instance Data.Foldable.Foldable Name where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Name where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Name where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamedLabelStatement a = NamedLabelStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Name a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_530.
        AST.Traversable1.Class.Traversable1 a_530
      )
  
  instance AST.Unmarshal.SymbolMatching NamedLabelStatement where
    matchedSymbols _ = [234]
    showFailure _ node_531 =
      "expected "
        GHC.Base.<> ( "named_label_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_531 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_531) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_532 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_533 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_534 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_535 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_532
          c1_533 = TreeSitter.Node.nodeStartPoint node_531
        TreeSitter.Node.TSPoint
          r2_534
          c2_535 = TreeSitter.Node.nodeEndPoint node_531
  
  deriving instance GHC.Classes.Eq a_536 => GHC.Classes.Eq (NamedLabelStatement a_536)
  
  deriving instance GHC.Classes.Ord a_537 => GHC.Classes.Ord (NamedLabelStatement a_537)
  
  deriving instance GHC.Show.Show a_538 => GHC.Show.Show (NamedLabelStatement a_538)
  
  instance AST.Unmarshal.Unmarshal NamedLabelStatement
  
  instance Data.Foldable.Foldable NamedLabelStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamedLabelStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamedLabelStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceAliasingClause a = NamespaceAliasingClause
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Name a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_539.
        AST.Traversable1.Class.Traversable1 a_539
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceAliasingClause where
    matchedSymbols _ = [168]
    showFailure _ node_540 =
      "expected "
        GHC.Base.<> ( "namespace_aliasing_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_540 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_540) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_541 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_542 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_543 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_544 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_541
          c1_542 = TreeSitter.Node.nodeStartPoint node_540
        TreeSitter.Node.TSPoint
          r2_543
          c2_544 = TreeSitter.Node.nodeEndPoint node_540
  
  deriving instance GHC.Classes.Eq a_545 => GHC.Classes.Eq (NamespaceAliasingClause a_545)
  
  deriving instance GHC.Classes.Ord a_546 => GHC.Classes.Ord (NamespaceAliasingClause a_546)
  
  deriving instance GHC.Show.Show a_547 => GHC.Show.Show (NamespaceAliasingClause a_547)
  
  instance AST.Unmarshal.Unmarshal NamespaceAliasingClause
  
  instance Data.Foldable.Foldable NamespaceAliasingClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceAliasingClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceAliasingClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceDefinition a = NamespaceDefinition
    { ann :: a,
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (CompoundStatement a))),
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (NamespaceName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_548.
        AST.Traversable1.Class.Traversable1 a_548
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceDefinition where
    matchedSymbols _ = [161]
    showFailure _ node_549 =
      "expected "
        GHC.Base.<> ( "namespace_definition"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_549 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_549) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_550 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_551 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_552 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_553 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_550
          c1_551 = TreeSitter.Node.nodeStartPoint node_549
        TreeSitter.Node.TSPoint
          r2_552
          c2_553 = TreeSitter.Node.nodeEndPoint node_549
  
  deriving instance GHC.Classes.Eq a_554 => GHC.Classes.Eq (NamespaceDefinition a_554)
  
  deriving instance GHC.Classes.Ord a_555 => GHC.Classes.Ord (NamespaceDefinition a_555)
  
  deriving instance GHC.Show.Show a_556 => GHC.Show.Show (NamespaceDefinition a_556)
  
  instance AST.Unmarshal.Unmarshal NamespaceDefinition
  
  instance Data.Foldable.Foldable NamespaceDefinition where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceDefinition where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceDefinition where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceFunctionOrConst a = NamespaceFunctionOrConst
    { ann :: a,
      text :: Data.Text.Internal.Text
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_557.
        AST.Traversable1.Class.Traversable1 a_557
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceFunctionOrConst where
    matchedSymbols _ = [163]
    showFailure _ node_558 =
      "expected "
        GHC.Base.<> ( "namespace_function_or_const"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_558 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_558) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_559 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_560 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_561 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_562 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_559
          c1_560 = TreeSitter.Node.nodeStartPoint node_558
        TreeSitter.Node.TSPoint
          r2_561
          c2_562 = TreeSitter.Node.nodeEndPoint node_558
  
  deriving instance GHC.Classes.Eq a_563 => GHC.Classes.Eq (NamespaceFunctionOrConst a_563)
  
  deriving instance GHC.Classes.Ord a_564 => GHC.Classes.Ord (NamespaceFunctionOrConst a_564)
  
  deriving instance GHC.Show.Show a_565 => GHC.Show.Show (NamespaceFunctionOrConst a_565)
  
  instance AST.Unmarshal.Unmarshal NamespaceFunctionOrConst
  
  instance Data.Foldable.Foldable NamespaceFunctionOrConst where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceFunctionOrConst where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceFunctionOrConst where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceName a = NamespaceName
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Name a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_566.
        AST.Traversable1.Class.Traversable1 a_566
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceName where
    matchedSymbols _ = [167]
    showFailure _ node_567 =
      "expected "
        GHC.Base.<> ( "namespace_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_567 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_567) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_568 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_569 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_570 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_571 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_568
          c1_569 = TreeSitter.Node.nodeStartPoint node_567
        TreeSitter.Node.TSPoint
          r2_570
          c2_571 = TreeSitter.Node.nodeEndPoint node_567
  
  deriving instance GHC.Classes.Eq a_572 => GHC.Classes.Eq (NamespaceName a_572)
  
  deriving instance GHC.Classes.Ord a_573 => GHC.Classes.Ord (NamespaceName a_573)
  
  deriving instance GHC.Show.Show a_574 => GHC.Show.Show (NamespaceName a_574)
  
  instance AST.Unmarshal.Unmarshal NamespaceName
  
  instance Data.Foldable.Foldable NamespaceName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceNameAsPrefix a = NamespaceNameAsPrefix
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (NamespaceName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_575.
        AST.Traversable1.Class.Traversable1 a_575
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceNameAsPrefix where
    matchedSymbols _ = [166]
    showFailure _ node_576 =
      "expected "
        GHC.Base.<> ( "namespace_name_as_prefix"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_576 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_576) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_577 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_578 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_579 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_580 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_577
          c1_578 = TreeSitter.Node.nodeStartPoint node_576
        TreeSitter.Node.TSPoint
          r2_579
          c2_580 = TreeSitter.Node.nodeEndPoint node_576
  
  deriving instance GHC.Classes.Eq a_581 => GHC.Classes.Eq (NamespaceNameAsPrefix a_581)
  
  deriving instance GHC.Classes.Ord a_582 => GHC.Classes.Ord (NamespaceNameAsPrefix a_582)
  
  deriving instance GHC.Show.Show a_583 => GHC.Show.Show (NamespaceNameAsPrefix a_583)
  
  instance AST.Unmarshal.Unmarshal NamespaceNameAsPrefix
  
  instance Data.Foldable.Foldable NamespaceNameAsPrefix where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceNameAsPrefix where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceNameAsPrefix where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceUseClause a = NamespaceUseClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((NamespaceAliasingClause GHC.Generics.:+: QualifiedName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_584.
        AST.Traversable1.Class.Traversable1 a_584
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceUseClause where
    matchedSymbols _ = [164]
    showFailure _ node_585 =
      "expected "
        GHC.Base.<> ( "namespace_use_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_585 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_585) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_586 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_587 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_588 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_589 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_586
          c1_587 = TreeSitter.Node.nodeStartPoint node_585
        TreeSitter.Node.TSPoint
          r2_588
          c2_589 = TreeSitter.Node.nodeEndPoint node_585
  
  deriving instance GHC.Classes.Eq a_590 => GHC.Classes.Eq (NamespaceUseClause a_590)
  
  deriving instance GHC.Classes.Ord a_591 => GHC.Classes.Ord (NamespaceUseClause a_591)
  
  deriving instance GHC.Show.Show a_592 => GHC.Show.Show (NamespaceUseClause a_592)
  
  instance AST.Unmarshal.Unmarshal NamespaceUseClause
  
  instance Data.Foldable.Foldable NamespaceUseClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceUseClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceUseClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceUseDeclaration a = NamespaceUseDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((NamespaceFunctionOrConst GHC.Generics.:+: NamespaceName GHC.Generics.:+: NamespaceUseClause GHC.Generics.:+: NamespaceUseGroup) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_593.
        AST.Traversable1.Class.Traversable1 a_593
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceUseDeclaration where
    matchedSymbols _ = [162]
    showFailure _ node_594 =
      "expected "
        GHC.Base.<> ( "namespace_use_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_594 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_594) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_595 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_596 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_597 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_598 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_595
          c1_596 = TreeSitter.Node.nodeStartPoint node_594
        TreeSitter.Node.TSPoint
          r2_597
          c2_598 = TreeSitter.Node.nodeEndPoint node_594
  
  deriving instance GHC.Classes.Eq a_599 => GHC.Classes.Eq (NamespaceUseDeclaration a_599)
  
  deriving instance GHC.Classes.Ord a_600 => GHC.Classes.Ord (NamespaceUseDeclaration a_600)
  
  deriving instance GHC.Show.Show a_601 => GHC.Show.Show (NamespaceUseDeclaration a_601)
  
  instance AST.Unmarshal.Unmarshal NamespaceUseDeclaration
  
  instance Data.Foldable.Foldable NamespaceUseDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceUseDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceUseDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceUseGroup a = NamespaceUseGroup
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (NamespaceUseGroupClause a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_602.
        AST.Traversable1.Class.Traversable1 a_602
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceUseGroup where
    matchedSymbols _ = [169]
    showFailure _ node_603 =
      "expected "
        GHC.Base.<> ( "namespace_use_group"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_603 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_603) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_604 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_605 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_606 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_607 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_604
          c1_605 = TreeSitter.Node.nodeStartPoint node_603
        TreeSitter.Node.TSPoint
          r2_606
          c2_607 = TreeSitter.Node.nodeEndPoint node_603
  
  deriving instance GHC.Classes.Eq a_608 => GHC.Classes.Eq (NamespaceUseGroup a_608)
  
  deriving instance GHC.Classes.Ord a_609 => GHC.Classes.Ord (NamespaceUseGroup a_609)
  
  deriving instance GHC.Show.Show a_610 => GHC.Show.Show (NamespaceUseGroup a_610)
  
  instance AST.Unmarshal.Unmarshal NamespaceUseGroup
  
  instance Data.Foldable.Foldable NamespaceUseGroup where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceUseGroup where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceUseGroup where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamespaceUseGroupClause a = NamespaceUseGroupClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((NamespaceAliasingClause GHC.Generics.:+: NamespaceFunctionOrConst GHC.Generics.:+: NamespaceName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_611.
        AST.Traversable1.Class.Traversable1 a_611
      )
  
  instance AST.Unmarshal.SymbolMatching NamespaceUseGroupClause where
    matchedSymbols _ = [170]
    showFailure _ node_612 =
      "expected "
        GHC.Base.<> ( "namespace_use_group_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_612 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_612) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_613 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_614 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_615 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_616 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_613
          c1_614 = TreeSitter.Node.nodeStartPoint node_612
        TreeSitter.Node.TSPoint
          r2_615
          c2_616 = TreeSitter.Node.nodeEndPoint node_612
  
  deriving instance GHC.Classes.Eq a_617 => GHC.Classes.Eq (NamespaceUseGroupClause a_617)
  
  deriving instance GHC.Classes.Ord a_618 => GHC.Classes.Ord (NamespaceUseGroupClause a_618)
  
  deriving instance GHC.Show.Show a_619 => GHC.Show.Show (NamespaceUseGroupClause a_619)
  
  instance AST.Unmarshal.Unmarshal NamespaceUseGroupClause
  
  instance Data.Foldable.Foldable NamespaceUseGroupClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamespaceUseGroupClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamespaceUseGroupClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ObjectCreationExpression a = ObjectCreationExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Arguments GHC.Generics.:+: ClassBaseClause GHC.Generics.:+: ClassInterfaceClause GHC.Generics.:+: DeclarationList GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_620.
        AST.Traversable1.Class.Traversable1 a_620
      )
  
  instance AST.Unmarshal.SymbolMatching ObjectCreationExpression where
    matchedSymbols _ = [247]
    showFailure _ node_621 =
      "expected "
        GHC.Base.<> ( "object_creation_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_621 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_621) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_622 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_623 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_624 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_625 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_622
          c1_623 = TreeSitter.Node.nodeStartPoint node_621
        TreeSitter.Node.TSPoint
          r2_624
          c2_625 = TreeSitter.Node.nodeEndPoint node_621
  
  deriving instance GHC.Classes.Eq a_626 => GHC.Classes.Eq (ObjectCreationExpression a_626)
  
  deriving instance GHC.Classes.Ord a_627 => GHC.Classes.Ord (ObjectCreationExpression a_627)
  
  deriving instance GHC.Show.Show a_628 => GHC.Show.Show (ObjectCreationExpression a_628)
  
  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 OptionalType a = OptionalType
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((PrimitiveType GHC.Generics.:+: TypeName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_629.
        AST.Traversable1.Class.Traversable1 a_629
      )
  
  instance AST.Unmarshal.SymbolMatching OptionalType where
    matchedSymbols _ = [198]
    showFailure _ node_630 =
      "expected "
        GHC.Base.<> ( "optional_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_630 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_630) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_631 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_632 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_633 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_634 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_631
          c1_632 = TreeSitter.Node.nodeStartPoint node_630
        TreeSitter.Node.TSPoint
          r2_633
          c2_634 = TreeSitter.Node.nodeEndPoint node_630
  
  deriving instance GHC.Classes.Eq a_635 => GHC.Classes.Eq (OptionalType a_635)
  
  deriving instance GHC.Classes.Ord a_636 => GHC.Classes.Ord (OptionalType a_636)
  
  deriving instance GHC.Show.Show a_637 => GHC.Show.Show (OptionalType a_637)
  
  instance AST.Unmarshal.Unmarshal OptionalType
  
  instance Data.Foldable.Foldable OptionalType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OptionalType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OptionalType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Pair a = Pair
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: ListLiteral) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_638.
        AST.Traversable1.Class.Traversable1 a_638
      )
  
  instance AST.Unmarshal.SymbolMatching Pair where
    matchedSymbols _ = [222]
    showFailure _ node_639 =
      "expected "
        GHC.Base.<> ( "pair"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_639 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_639) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_640 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_641 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_642 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_643 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_640
          c1_641 = TreeSitter.Node.nodeStartPoint node_639
        TreeSitter.Node.TSPoint
          r2_642
          c2_643 = TreeSitter.Node.nodeEndPoint node_639
  
  deriving instance GHC.Classes.Eq a_644 => GHC.Classes.Eq (Pair a_644)
  
  deriving instance GHC.Classes.Ord a_645 => GHC.Classes.Ord (Pair a_645)
  
  deriving instance GHC.Show.Show a_646 => GHC.Show.Show (Pair a_646)
  
  instance AST.Unmarshal.Unmarshal Pair
  
  instance Data.Foldable.Foldable Pair where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Pair where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Pair 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_647.
        AST.Traversable1.Class.Traversable1 a_647
      )
  
  instance AST.Unmarshal.SymbolMatching ParenthesizedExpression where
    matchedSymbols _ = [242]
    showFailure _ node_648 =
      "expected "
        GHC.Base.<> ( "parenthesized_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_648 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_648) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_649 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_650 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_651 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_652 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_649
          c1_650 = TreeSitter.Node.nodeStartPoint node_648
        TreeSitter.Node.TSPoint
          r2_651
          c2_652 = TreeSitter.Node.nodeEndPoint node_648
  
  deriving instance GHC.Classes.Eq a_653 => GHC.Classes.Eq (ParenthesizedExpression a_653)
  
  deriving instance GHC.Classes.Ord a_654 => GHC.Classes.Ord (ParenthesizedExpression a_654)
  
  deriving instance GHC.Show.Show a_655 => GHC.Show.Show (ParenthesizedExpression a_655)
  
  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 PrimitiveType a = PrimitiveType {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_656.
        AST.Traversable1.Class.Traversable1 a_656
      )
  
  instance AST.Unmarshal.SymbolMatching PrimitiveType where
    matchedSymbols _ = [199]
    showFailure _ node_657 =
      "expected "
        GHC.Base.<> ( "primitive_type"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_657 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_657) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_658 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_659 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_660 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_661 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_658
          c1_659 = TreeSitter.Node.nodeStartPoint node_657
        TreeSitter.Node.TSPoint
          r2_660
          c2_661 = TreeSitter.Node.nodeEndPoint node_657
  
  deriving instance GHC.Classes.Eq a_662 => GHC.Classes.Eq (PrimitiveType a_662)
  
  deriving instance GHC.Classes.Ord a_663 => GHC.Classes.Ord (PrimitiveType a_663)
  
  deriving instance GHC.Show.Show a_664 => GHC.Show.Show (PrimitiveType a_664)
  
  instance AST.Unmarshal.Unmarshal PrimitiveType
  
  instance Data.Foldable.Foldable PrimitiveType where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PrimitiveType where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PrimitiveType where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PrintIntrinsic a = PrintIntrinsic
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_665.
        AST.Traversable1.Class.Traversable1 a_665
      )
  
  instance AST.Unmarshal.SymbolMatching PrintIntrinsic where
    matchedSymbols _ = [244]
    showFailure _ node_666 =
      "expected "
        GHC.Base.<> ( "print_intrinsic"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_666 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_666) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_667 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_668 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_669 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_670 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_667
          c1_668 = TreeSitter.Node.nodeStartPoint node_666
        TreeSitter.Node.TSPoint
          r2_669
          c2_670 = TreeSitter.Node.nodeEndPoint node_666
  
  deriving instance GHC.Classes.Eq a_671 => GHC.Classes.Eq (PrintIntrinsic a_671)
  
  deriving instance GHC.Classes.Ord a_672 => GHC.Classes.Ord (PrintIntrinsic a_672)
  
  deriving instance GHC.Show.Show a_673 => GHC.Show.Show (PrintIntrinsic a_673)
  
  instance AST.Unmarshal.Unmarshal PrintIntrinsic
  
  instance Data.Foldable.Foldable PrintIntrinsic where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PrintIntrinsic where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PrintIntrinsic where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Program a = Program
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: PhpTag GHC.Generics.:+: Text) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_674.
        AST.Traversable1.Class.Traversable1 a_674
      )
  
  instance AST.Unmarshal.SymbolMatching Program where
    matchedSymbols _ = [154]
    showFailure _ node_675 =
      "expected "
        GHC.Base.<> ( "program"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_675 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_675) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_676 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_677 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_678 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_679 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_676
          c1_677 = TreeSitter.Node.nodeStartPoint node_675
        TreeSitter.Node.TSPoint
          r2_678
          c2_679 = TreeSitter.Node.nodeEndPoint node_675
  
  deriving instance GHC.Classes.Eq a_680 => GHC.Classes.Eq (Program a_680)
  
  deriving instance GHC.Classes.Ord a_681 => GHC.Classes.Ord (Program a_681)
  
  deriving instance GHC.Show.Show a_682 => GHC.Show.Show (Program a_682)
  
  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 PropertyDeclaration a = PropertyDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ClassModifier GHC.Generics.:+: PropertyElement GHC.Generics.:+: StaticModifier GHC.Generics.:+: VarModifier GHC.Generics.:+: VisibilityModifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_683.
        AST.Traversable1.Class.Traversable1 a_683
      )
  
  instance AST.Unmarshal.SymbolMatching PropertyDeclaration where
    matchedSymbols _ = [181]
    showFailure _ node_684 =
      "expected "
        GHC.Base.<> ( "property_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_684 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_684) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_685 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_686 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_687 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_688 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_685
          c1_686 = TreeSitter.Node.nodeStartPoint node_684
        TreeSitter.Node.TSPoint
          r2_687
          c2_688 = TreeSitter.Node.nodeEndPoint node_684
  
  deriving instance GHC.Classes.Eq a_689 => GHC.Classes.Eq (PropertyDeclaration a_689)
  
  deriving instance GHC.Classes.Ord a_690 => GHC.Classes.Ord (PropertyDeclaration a_690)
  
  deriving instance GHC.Show.Show a_691 => GHC.Show.Show (PropertyDeclaration a_691)
  
  instance AST.Unmarshal.Unmarshal PropertyDeclaration
  
  instance Data.Foldable.Foldable PropertyDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PropertyDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PropertyDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PropertyElement a = PropertyElement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((PropertyInitializer GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_692.
        AST.Traversable1.Class.Traversable1 a_692
      )
  
  instance AST.Unmarshal.SymbolMatching PropertyElement where
    matchedSymbols _ = [183]
    showFailure _ node_693 =
      "expected "
        GHC.Base.<> ( "property_element"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_693 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_693) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_694 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_695 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_696 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_697 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_694
          c1_695 = TreeSitter.Node.nodeStartPoint node_693
        TreeSitter.Node.TSPoint
          r2_696
          c2_697 = TreeSitter.Node.nodeEndPoint node_693
  
  deriving instance GHC.Classes.Eq a_698 => GHC.Classes.Eq (PropertyElement a_698)
  
  deriving instance GHC.Classes.Ord a_699 => GHC.Classes.Ord (PropertyElement a_699)
  
  deriving instance GHC.Show.Show a_700 => GHC.Show.Show (PropertyElement a_700)
  
  instance AST.Unmarshal.Unmarshal PropertyElement
  
  instance Data.Foldable.Foldable PropertyElement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PropertyElement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PropertyElement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PropertyInitializer a = PropertyInitializer
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_701.
        AST.Traversable1.Class.Traversable1 a_701
      )
  
  instance AST.Unmarshal.SymbolMatching PropertyInitializer where
    matchedSymbols _ = [184]
    showFailure _ node_702 =
      "expected "
        GHC.Base.<> ( "property_initializer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_702 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_702) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_703 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_704 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_705 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_706 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_703
          c1_704 = TreeSitter.Node.nodeStartPoint node_702
        TreeSitter.Node.TSPoint
          r2_705
          c2_706 = TreeSitter.Node.nodeEndPoint node_702
  
  deriving instance GHC.Classes.Eq a_707 => GHC.Classes.Eq (PropertyInitializer a_707)
  
  deriving instance GHC.Classes.Ord a_708 => GHC.Classes.Ord (PropertyInitializer a_708)
  
  deriving instance GHC.Show.Show a_709 => GHC.Show.Show (PropertyInitializer a_709)
  
  instance AST.Unmarshal.Unmarshal PropertyInitializer
  
  instance Data.Foldable.Foldable PropertyInitializer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PropertyInitializer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PropertyInitializer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data QualifiedName a = QualifiedName
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Name GHC.Generics.:+: NamespaceNameAsPrefix) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_710.
        AST.Traversable1.Class.Traversable1 a_710
      )
  
  instance AST.Unmarshal.SymbolMatching QualifiedName where
    matchedSymbols _ = [165]
    showFailure _ node_711 =
      "expected "
        GHC.Base.<> ( "qualified_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_711 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_711) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_712 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_713 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_714 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_715 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_712
          c1_713 = TreeSitter.Node.nodeStartPoint node_711
        TreeSitter.Node.TSPoint
          r2_714
          c2_715 = TreeSitter.Node.nodeEndPoint node_711
  
  deriving instance GHC.Classes.Eq a_716 => GHC.Classes.Eq (QualifiedName a_716)
  
  deriving instance GHC.Classes.Ord a_717 => GHC.Classes.Ord (QualifiedName a_717)
  
  deriving instance GHC.Show.Show a_718 => GHC.Show.Show (QualifiedName a_718)
  
  instance AST.Unmarshal.Unmarshal QualifiedName
  
  instance Data.Foldable.Foldable QualifiedName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor QualifiedName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable QualifiedName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RelativeScope a = RelativeScope {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_719.
        AST.Traversable1.Class.Traversable1 a_719
      )
  
  instance AST.Unmarshal.SymbolMatching RelativeScope where
    matchedSymbols _ = [260]
    showFailure _ node_720 =
      "expected "
        GHC.Base.<> ( "relative_scope"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_720 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_720) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_721 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_722 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_723 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_724 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_721
          c1_722 = TreeSitter.Node.nodeStartPoint node_720
        TreeSitter.Node.TSPoint
          r2_723
          c2_724 = TreeSitter.Node.nodeEndPoint node_720
  
  deriving instance GHC.Classes.Eq a_725 => GHC.Classes.Eq (RelativeScope a_725)
  
  deriving instance GHC.Classes.Ord a_726 => GHC.Classes.Ord (RelativeScope a_726)
  
  deriving instance GHC.Show.Show a_727 => GHC.Show.Show (RelativeScope a_727)
  
  instance AST.Unmarshal.Unmarshal RelativeScope
  
  instance Data.Foldable.Foldable RelativeScope where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RelativeScope where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RelativeScope where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RequireExpression a = RequireExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_728.
        AST.Traversable1.Class.Traversable1 a_728
      )
  
  instance AST.Unmarshal.SymbolMatching RequireExpression where
    matchedSymbols _ = [275]
    showFailure _ node_729 =
      "expected "
        GHC.Base.<> ( "require_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_729 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_729) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_730 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_731 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_732 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_733 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_730
          c1_731 = TreeSitter.Node.nodeStartPoint node_729
        TreeSitter.Node.TSPoint
          r2_732
          c2_733 = TreeSitter.Node.nodeEndPoint node_729
  
  deriving instance GHC.Classes.Eq a_734 => GHC.Classes.Eq (RequireExpression a_734)
  
  deriving instance GHC.Classes.Ord a_735 => GHC.Classes.Ord (RequireExpression a_735)
  
  deriving instance GHC.Show.Show a_736 => GHC.Show.Show (RequireExpression a_736)
  
  instance AST.Unmarshal.Unmarshal RequireExpression
  
  instance Data.Foldable.Foldable RequireExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RequireExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RequireExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RequireOnceExpression a = RequireOnceExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_737.
        AST.Traversable1.Class.Traversable1 a_737
      )
  
  instance AST.Unmarshal.SymbolMatching RequireOnceExpression where
    matchedSymbols _ = [276]
    showFailure _ node_738 =
      "expected "
        GHC.Base.<> ( "require_once_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_738 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_738) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_739 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_740 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_741 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_742 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_739
          c1_740 = TreeSitter.Node.nodeStartPoint node_738
        TreeSitter.Node.TSPoint
          r2_741
          c2_742 = TreeSitter.Node.nodeEndPoint node_738
  
  deriving instance GHC.Classes.Eq a_743 => GHC.Classes.Eq (RequireOnceExpression a_743)
  
  deriving instance GHC.Classes.Ord a_744 => GHC.Classes.Ord (RequireOnceExpression a_744)
  
  deriving instance GHC.Show.Show a_745 => GHC.Show.Show (RequireOnceExpression a_745)
  
  instance AST.Unmarshal.Unmarshal RequireOnceExpression
  
  instance Data.Foldable.Foldable RequireOnceExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RequireOnceExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RequireOnceExpression 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_746.
        AST.Traversable1.Class.Traversable1 a_746
      )
  
  instance AST.Unmarshal.SymbolMatching ReturnStatement where
    matchedSymbols _ = [214]
    showFailure _ node_747 =
      "expected "
        GHC.Base.<> ( "return_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_747 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_747) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_748 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_749 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_750 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_751 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_748
          c1_749 = TreeSitter.Node.nodeStartPoint node_747
        TreeSitter.Node.TSPoint
          r2_750
          c2_751 = TreeSitter.Node.nodeEndPoint node_747
  
  deriving instance GHC.Classes.Eq a_752 => GHC.Classes.Eq (ReturnStatement a_752)
  
  deriving instance GHC.Classes.Ord a_753 => GHC.Classes.Ord (ReturnStatement a_753)
  
  deriving instance GHC.Show.Show a_754 => GHC.Show.Show (ReturnStatement a_754)
  
  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 ScopedCallExpression a = ScopedCallExpression
    { ann :: a,
      arguments :: (AST.Parse.Err (Arguments a)),
      name :: (AST.Parse.Err ((Expression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: Name GHC.Generics.:+: VariableName) a)),
      scope :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: RelativeScope GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_755.
        AST.Traversable1.Class.Traversable1 a_755
      )
  
  instance AST.Unmarshal.SymbolMatching ScopedCallExpression where
    matchedSymbols _ = [258]
    showFailure _ node_756 =
      "expected "
        GHC.Base.<> ( "scoped_call_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_756 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_756) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_757 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_758 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_759 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_760 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_757
          c1_758 = TreeSitter.Node.nodeStartPoint node_756
        TreeSitter.Node.TSPoint
          r2_759
          c2_760 = TreeSitter.Node.nodeEndPoint node_756
  
  deriving instance GHC.Classes.Eq a_761 => GHC.Classes.Eq (ScopedCallExpression a_761)
  
  deriving instance GHC.Classes.Ord a_762 => GHC.Classes.Ord (ScopedCallExpression a_762)
  
  deriving instance GHC.Show.Show a_763 => GHC.Show.Show (ScopedCallExpression a_763)
  
  instance AST.Unmarshal.Unmarshal ScopedCallExpression
  
  instance Data.Foldable.Foldable ScopedCallExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ScopedCallExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ScopedCallExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ScopedPropertyAccessExpression a = ScopedPropertyAccessExpression
    { ann :: a,
      name :: (AST.Parse.Err ((DynamicVariableName GHC.Generics.:+: VariableName) a)),
      scope :: (AST.Parse.Err ((ArrayCreationExpression GHC.Generics.:+: CastExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: QualifiedName GHC.Generics.:+: RelativeScope GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_764.
        AST.Traversable1.Class.Traversable1 a_764
      )
  
  instance AST.Unmarshal.SymbolMatching ScopedPropertyAccessExpression where
    matchedSymbols _ = [255]
    showFailure _ node_765 =
      "expected "
        GHC.Base.<> ( "scoped_property_access_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_765 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_765) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_766 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_767 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_768 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_769 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_766
          c1_767 = TreeSitter.Node.nodeStartPoint node_765
        TreeSitter.Node.TSPoint
          r2_768
          c2_769 = TreeSitter.Node.nodeEndPoint node_765
  
  deriving instance GHC.Classes.Eq a_770 => GHC.Classes.Eq (ScopedPropertyAccessExpression a_770)
  
  deriving instance GHC.Classes.Ord a_771 => GHC.Classes.Ord (ScopedPropertyAccessExpression a_771)
  
  deriving instance GHC.Show.Show a_772 => GHC.Show.Show (ScopedPropertyAccessExpression a_772)
  
  instance AST.Unmarshal.Unmarshal ScopedPropertyAccessExpression
  
  instance Data.Foldable.Foldable ScopedPropertyAccessExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ScopedPropertyAccessExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ScopedPropertyAccessExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SequenceExpression a = SequenceExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_773.
        AST.Traversable1.Class.Traversable1 a_773
      )
  
  instance AST.Unmarshal.SymbolMatching SequenceExpression where
    matchedSymbols _ = [220]
    showFailure _ node_774 =
      "expected "
        GHC.Base.<> ( "sequence_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_774 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_774) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_775 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_776 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_777 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_778 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_775
          c1_776 = TreeSitter.Node.nodeStartPoint node_774
        TreeSitter.Node.TSPoint
          r2_777
          c2_778 = TreeSitter.Node.nodeEndPoint node_774
  
  deriving instance GHC.Classes.Eq a_779 => GHC.Classes.Eq (SequenceExpression a_779)
  
  deriving instance GHC.Classes.Ord a_780 => GHC.Classes.Ord (SequenceExpression a_780)
  
  deriving instance GHC.Show.Show a_781 => GHC.Show.Show (SequenceExpression a_781)
  
  instance AST.Unmarshal.Unmarshal SequenceExpression
  
  instance Data.Foldable.Foldable SequenceExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SequenceExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SequenceExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SimpleParameter a = SimpleParameter
    { ann :: a,
      defaultValue :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      name :: (AST.Parse.Err (VariableName a)),
      type' :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_782.
        AST.Traversable1.Class.Traversable1 a_782
      )
  
  instance AST.Unmarshal.SymbolMatching SimpleParameter where
    matchedSymbols _ = [195]
    showFailure _ node_783 =
      "expected "
        GHC.Base.<> ( "simple_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_783 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_783) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_784 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_785 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_786 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_787 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_784
          c1_785 = TreeSitter.Node.nodeStartPoint node_783
        TreeSitter.Node.TSPoint
          r2_786
          c2_787 = TreeSitter.Node.nodeEndPoint node_783
  
  deriving instance GHC.Classes.Eq a_788 => GHC.Classes.Eq (SimpleParameter a_788)
  
  deriving instance GHC.Classes.Ord a_789 => GHC.Classes.Ord (SimpleParameter a_789)
  
  deriving instance GHC.Show.Show a_790 => GHC.Show.Show (SimpleParameter a_790)
  
  instance AST.Unmarshal.Unmarshal SimpleParameter
  
  instance Data.Foldable.Foldable SimpleParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SimpleParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SimpleParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data StaticModifier a = StaticModifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_791.
        AST.Traversable1.Class.Traversable1 a_791
      )
  
  instance AST.Unmarshal.SymbolMatching StaticModifier where
    matchedSymbols _ = [186]
    showFailure _ node_792 =
      "expected "
        GHC.Base.<> ( "static_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_792 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_792) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_793 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_794 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_795 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_796 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_793
          c1_794 = TreeSitter.Node.nodeStartPoint node_792
        TreeSitter.Node.TSPoint
          r2_795
          c2_796 = TreeSitter.Node.nodeEndPoint node_792
  
  deriving instance GHC.Classes.Eq a_797 => GHC.Classes.Eq (StaticModifier a_797)
  
  deriving instance GHC.Classes.Ord a_798 => GHC.Classes.Ord (StaticModifier a_798)
  
  deriving instance GHC.Show.Show a_799 => GHC.Show.Show (StaticModifier a_799)
  
  instance AST.Unmarshal.Unmarshal StaticModifier
  
  instance Data.Foldable.Foldable StaticModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor StaticModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable StaticModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data StaticVariableDeclaration a = StaticVariableDeclaration
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      name :: (AST.Parse.Err (VariableName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_800.
        AST.Traversable1.Class.Traversable1 a_800
      )
  
  instance AST.Unmarshal.SymbolMatching StaticVariableDeclaration where
    matchedSymbols _ = [159]
    showFailure _ node_801 =
      "expected "
        GHC.Base.<> ( "static_variable_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_801 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_801) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_802 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_803 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_804 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_805 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_802
          c1_803 = TreeSitter.Node.nodeStartPoint node_801
        TreeSitter.Node.TSPoint
          r2_804
          c2_805 = TreeSitter.Node.nodeEndPoint node_801
  
  deriving instance GHC.Classes.Eq a_806 => GHC.Classes.Eq (StaticVariableDeclaration a_806)
  
  deriving instance GHC.Classes.Ord a_807 => GHC.Classes.Ord (StaticVariableDeclaration a_807)
  
  deriving instance GHC.Show.Show a_808 => GHC.Show.Show (StaticVariableDeclaration a_808)
  
  instance AST.Unmarshal.Unmarshal StaticVariableDeclaration
  
  instance Data.Foldable.Foldable StaticVariableDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor StaticVariableDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable StaticVariableDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SubscriptExpression a = SubscriptExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: ArrayCreationExpression GHC.Generics.:+: ClassConstantAccessExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: Heredoc GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_809.
        AST.Traversable1.Class.Traversable1 a_809
      )
  
  instance AST.Unmarshal.SymbolMatching SubscriptExpression where
    matchedSymbols _ = [264]
    showFailure _ node_810 =
      "expected "
        GHC.Base.<> ( "subscript_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_810 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_810) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_811 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_812 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_813 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_814 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_811
          c1_812 = TreeSitter.Node.nodeStartPoint node_810
        TreeSitter.Node.TSPoint
          r2_813
          c2_814 = TreeSitter.Node.nodeEndPoint node_810
  
  deriving instance GHC.Classes.Eq a_815 => GHC.Classes.Eq (SubscriptExpression a_815)
  
  deriving instance GHC.Classes.Ord a_816 => GHC.Classes.Ord (SubscriptExpression a_816)
  
  deriving instance GHC.Show.Show a_817 => GHC.Show.Show (SubscriptExpression a_817)
  
  instance AST.Unmarshal.Unmarshal SubscriptExpression
  
  instance Data.Foldable.Foldable SubscriptExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SubscriptExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SubscriptExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SwitchBlock a = SwitchBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((CaseStatement GHC.Generics.:+: DefaultStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_818.
        AST.Traversable1.Class.Traversable1 a_818
      )
  
  instance AST.Unmarshal.SymbolMatching SwitchBlock where
    matchedSymbols _ = [230]
    showFailure _ node_819 =
      "expected "
        GHC.Base.<> ( "switch_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_819 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_819) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_820 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_821 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_822 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_823 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_820
          c1_821 = TreeSitter.Node.nodeStartPoint node_819
        TreeSitter.Node.TSPoint
          r2_822
          c2_823 = TreeSitter.Node.nodeEndPoint node_819
  
  deriving instance GHC.Classes.Eq a_824 => GHC.Classes.Eq (SwitchBlock a_824)
  
  deriving instance GHC.Classes.Ord a_825 => GHC.Classes.Ord (SwitchBlock a_825)
  
  deriving instance GHC.Show.Show a_826 => GHC.Show.Show (SwitchBlock a_826)
  
  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 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_827.
        AST.Traversable1.Class.Traversable1 a_827
      )
  
  instance AST.Unmarshal.SymbolMatching SwitchStatement where
    matchedSymbols _ = [229]
    showFailure _ node_828 =
      "expected "
        GHC.Base.<> ( "switch_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_828 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_828) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_829 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_830 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_831 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_832 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_829
          c1_830 = TreeSitter.Node.nodeStartPoint node_828
        TreeSitter.Node.TSPoint
          r2_831
          c2_832 = TreeSitter.Node.nodeEndPoint node_828
  
  deriving instance GHC.Classes.Eq a_833 => GHC.Classes.Eq (SwitchStatement a_833)
  
  deriving instance GHC.Classes.Ord a_834 => GHC.Classes.Ord (SwitchStatement a_834)
  
  deriving instance GHC.Show.Show a_835 => GHC.Show.Show (SwitchStatement a_835)
  
  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 Text a = Text {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_836.
        AST.Traversable1.Class.Traversable1 a_836
      )
  
  instance AST.Unmarshal.SymbolMatching Text where
    matchedSymbols _ = [156]
    showFailure _ node_837 =
      "expected "
        GHC.Base.<> ( "text"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_837 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_837) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_838 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_839 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_840 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_841 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_838
          c1_839 = TreeSitter.Node.nodeStartPoint node_837
        TreeSitter.Node.TSPoint
          r2_840
          c2_841 = TreeSitter.Node.nodeEndPoint node_837
  
  deriving instance GHC.Classes.Eq a_842 => GHC.Classes.Eq (Text a_842)
  
  deriving instance GHC.Classes.Ord a_843 => GHC.Classes.Ord (Text a_843)
  
  deriving instance GHC.Show.Show a_844 => GHC.Show.Show (Text a_844)
  
  instance AST.Unmarshal.Unmarshal Text
  
  instance Data.Foldable.Foldable Text where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Text where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Text 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_845.
        AST.Traversable1.Class.Traversable1 a_845
      )
  
  instance AST.Unmarshal.SymbolMatching ThrowStatement where
    matchedSymbols _ = [215]
    showFailure _ node_846 =
      "expected "
        GHC.Base.<> ( "throw_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_846 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_846) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_847 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_848 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_849 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_850 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_847
          c1_848 = TreeSitter.Node.nodeStartPoint node_846
        TreeSitter.Node.TSPoint
          r2_849
          c2_850 = TreeSitter.Node.nodeEndPoint node_846
  
  deriving instance GHC.Classes.Eq a_851 => GHC.Classes.Eq (ThrowStatement a_851)
  
  deriving instance GHC.Classes.Ord a_852 => GHC.Classes.Ord (ThrowStatement a_852)
  
  deriving instance GHC.Show.Show a_853 => GHC.Show.Show (ThrowStatement a_853)
  
  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 TraitDeclaration a = TraitDeclaration
    { ann :: a,
      body :: (AST.Parse.Err (DeclarationList a)),
      name :: (AST.Parse.Err (Name a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_854.
        AST.Traversable1.Class.Traversable1 a_854
      )
  
  instance AST.Unmarshal.SymbolMatching TraitDeclaration where
    matchedSymbols _ = [171]
    showFailure _ node_855 =
      "expected "
        GHC.Base.<> ( "trait_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_855 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_855) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_856 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_857 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_858 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_859 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_856
          c1_857 = TreeSitter.Node.nodeStartPoint node_855
        TreeSitter.Node.TSPoint
          r2_858
          c2_859 = TreeSitter.Node.nodeEndPoint node_855
  
  deriving instance GHC.Classes.Eq a_860 => GHC.Classes.Eq (TraitDeclaration a_860)
  
  deriving instance GHC.Classes.Ord a_861 => GHC.Classes.Ord (TraitDeclaration a_861)
  
  deriving instance GHC.Show.Show a_862 => GHC.Show.Show (TraitDeclaration a_862)
  
  instance AST.Unmarshal.Unmarshal TraitDeclaration
  
  instance Data.Foldable.Foldable TraitDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TraitDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TraitDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TryStatement a = TryStatement
    { ann :: a,
      body :: (AST.Parse.Err (CompoundStatement 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_863.
        AST.Traversable1.Class.Traversable1 a_863
      )
  
  instance AST.Unmarshal.SymbolMatching TryStatement where
    matchedSymbols _ = [207]
    showFailure _ node_864 =
      "expected "
        GHC.Base.<> ( "try_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_864 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_864) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_865 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_866 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_867 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_868 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_865
          c1_866 = TreeSitter.Node.nodeStartPoint node_864
        TreeSitter.Node.TSPoint
          r2_867
          c2_868 = TreeSitter.Node.nodeEndPoint node_864
  
  deriving instance GHC.Classes.Eq a_869 => GHC.Classes.Eq (TryStatement a_869)
  
  deriving instance GHC.Classes.Ord a_870 => GHC.Classes.Ord (TryStatement a_870)
  
  deriving instance GHC.Show.Show a_871 => GHC.Show.Show (TryStatement a_871)
  
  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 TypeName a = TypeName
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Name GHC.Generics.:+: NamespaceNameAsPrefix) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_872.
        AST.Traversable1.Class.Traversable1 a_872
      )
  
  instance AST.Unmarshal.SymbolMatching TypeName where
    matchedSymbols _ = [301]
    showFailure _ node_873 =
      "expected "
        GHC.Base.<> ( "type_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_873 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_873) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_874 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_875 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_876 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_877 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_874
          c1_875 = TreeSitter.Node.nodeStartPoint node_873
        TreeSitter.Node.TSPoint
          r2_876
          c2_877 = TreeSitter.Node.nodeEndPoint node_873
  
  deriving instance GHC.Classes.Eq a_878 => GHC.Classes.Eq (TypeName a_878)
  
  deriving instance GHC.Classes.Ord a_879 => GHC.Classes.Ord (TypeName a_879)
  
  deriving instance GHC.Show.Show a_880 => GHC.Show.Show (TypeName a_880)
  
  instance AST.Unmarshal.Unmarshal TypeName
  
  instance Data.Foldable.Foldable TypeName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnaryOpExpression a = UnaryOpExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_881.
        AST.Traversable1.Class.Traversable1 a_881
      )
  
  instance AST.Unmarshal.SymbolMatching UnaryOpExpression where
    matchedSymbols _ = [238]
    showFailure _ node_882 =
      "expected "
        GHC.Base.<> ( "unary_op_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_882 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_882) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_883 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_884 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_885 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_886 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_883
          c1_884 = TreeSitter.Node.nodeStartPoint node_882
        TreeSitter.Node.TSPoint
          r2_885
          c2_886 = TreeSitter.Node.nodeEndPoint node_882
  
  deriving instance GHC.Classes.Eq a_887 => GHC.Classes.Eq (UnaryOpExpression a_887)
  
  deriving instance GHC.Classes.Ord a_888 => GHC.Classes.Ord (UnaryOpExpression a_888)
  
  deriving instance GHC.Show.Show a_889 => GHC.Show.Show (UnaryOpExpression a_889)
  
  instance AST.Unmarshal.Unmarshal UnaryOpExpression
  
  instance Data.Foldable.Foldable UnaryOpExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnaryOpExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnaryOpExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnsetStatement a = UnsetStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((CastExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_890.
        AST.Traversable1.Class.Traversable1 a_890
      )
  
  instance AST.Unmarshal.SymbolMatching UnsetStatement where
    matchedSymbols _ = [204]
    showFailure _ node_891 =
      "expected "
        GHC.Base.<> ( "unset_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_891 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_891) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_892 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_893 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_894 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_895 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_892
          c1_893 = TreeSitter.Node.nodeStartPoint node_891
        TreeSitter.Node.TSPoint
          r2_894
          c2_895 = TreeSitter.Node.nodeEndPoint node_891
  
  deriving instance GHC.Classes.Eq a_896 => GHC.Classes.Eq (UnsetStatement a_896)
  
  deriving instance GHC.Classes.Ord a_897 => GHC.Classes.Ord (UnsetStatement a_897)
  
  deriving instance GHC.Show.Show a_898 => GHC.Show.Show (UnsetStatement a_898)
  
  instance AST.Unmarshal.Unmarshal UnsetStatement
  
  instance Data.Foldable.Foldable UnsetStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnsetStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnsetStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UpdateExpression a = UpdateExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((CastExpression GHC.Generics.:+: DynamicVariableName GHC.Generics.:+: FunctionCallExpression GHC.Generics.:+: MemberAccessExpression GHC.Generics.:+: MemberCallExpression GHC.Generics.:+: ScopedCallExpression GHC.Generics.:+: ScopedPropertyAccessExpression GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: VariableName) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_899.
        AST.Traversable1.Class.Traversable1 a_899
      )
  
  instance AST.Unmarshal.SymbolMatching UpdateExpression where
    matchedSymbols _ = [248]
    showFailure _ node_900 =
      "expected "
        GHC.Base.<> ( "update_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_900 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_900) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_901 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_902 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_903 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_904 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_901
          c1_902 = TreeSitter.Node.nodeStartPoint node_900
        TreeSitter.Node.TSPoint
          r2_903
          c2_904 = TreeSitter.Node.nodeEndPoint node_900
  
  deriving instance GHC.Classes.Eq a_905 => GHC.Classes.Eq (UpdateExpression a_905)
  
  deriving instance GHC.Classes.Ord a_906 => GHC.Classes.Ord (UpdateExpression a_906)
  
  deriving instance GHC.Show.Show a_907 => GHC.Show.Show (UpdateExpression a_907)
  
  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 UseAsClause a = UseAsClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ClassConstantAccessExpression GHC.Generics.:+: Name GHC.Generics.:+: VisibilityModifier) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_908.
        AST.Traversable1.Class.Traversable1 a_908
      )
  
  instance AST.Unmarshal.SymbolMatching UseAsClause where
    matchedSymbols _ = [190]
    showFailure _ node_909 =
      "expected "
        GHC.Base.<> ( "use_as_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_909 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_909) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_910 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_911 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_912 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_913 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_910
          c1_911 = TreeSitter.Node.nodeStartPoint node_909
        TreeSitter.Node.TSPoint
          r2_912
          c2_913 = TreeSitter.Node.nodeEndPoint node_909
  
  deriving instance GHC.Classes.Eq a_914 => GHC.Classes.Eq (UseAsClause a_914)
  
  deriving instance GHC.Classes.Ord a_915 => GHC.Classes.Ord (UseAsClause a_915)
  
  deriving instance GHC.Show.Show a_916 => GHC.Show.Show (UseAsClause a_916)
  
  instance AST.Unmarshal.Unmarshal UseAsClause
  
  instance Data.Foldable.Foldable UseAsClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UseAsClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UseAsClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UseDeclaration a = UseDeclaration
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((QualifiedName GHC.Generics.:+: UseList) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_917.
        AST.Traversable1.Class.Traversable1 a_917
      )
  
  instance AST.Unmarshal.SymbolMatching UseDeclaration where
    matchedSymbols _ = [187]
    showFailure _ node_918 =
      "expected "
        GHC.Base.<> ( "use_declaration"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_918 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_918) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_919 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_920 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_921 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_922 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_919
          c1_920 = TreeSitter.Node.nodeStartPoint node_918
        TreeSitter.Node.TSPoint
          r2_921
          c2_922 = TreeSitter.Node.nodeEndPoint node_918
  
  deriving instance GHC.Classes.Eq a_923 => GHC.Classes.Eq (UseDeclaration a_923)
  
  deriving instance GHC.Classes.Ord a_924 => GHC.Classes.Ord (UseDeclaration a_924)
  
  deriving instance GHC.Show.Show a_925 => GHC.Show.Show (UseDeclaration a_925)
  
  instance AST.Unmarshal.Unmarshal UseDeclaration
  
  instance Data.Foldable.Foldable UseDeclaration where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UseDeclaration where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UseDeclaration where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UseInsteadOfClause a = UseInsteadOfClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ClassConstantAccessExpression GHC.Generics.:+: Name) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_926.
        AST.Traversable1.Class.Traversable1 a_926
      )
  
  instance AST.Unmarshal.SymbolMatching UseInsteadOfClause where
    matchedSymbols _ = [189]
    showFailure _ node_927 =
      "expected "
        GHC.Base.<> ( "use_instead_of_clause"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_927 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_927) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_928 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_929 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_930 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_931 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_928
          c1_929 = TreeSitter.Node.nodeStartPoint node_927
        TreeSitter.Node.TSPoint
          r2_930
          c2_931 = TreeSitter.Node.nodeEndPoint node_927
  
  deriving instance GHC.Classes.Eq a_932 => GHC.Classes.Eq (UseInsteadOfClause a_932)
  
  deriving instance GHC.Classes.Ord a_933 => GHC.Classes.Ord (UseInsteadOfClause a_933)
  
  deriving instance GHC.Show.Show a_934 => GHC.Show.Show (UseInsteadOfClause a_934)
  
  instance AST.Unmarshal.Unmarshal UseInsteadOfClause
  
  instance Data.Foldable.Foldable UseInsteadOfClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UseInsteadOfClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UseInsteadOfClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UseList a = UseList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((UseAsClause GHC.Generics.:+: UseInsteadOfClause) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_935.
        AST.Traversable1.Class.Traversable1 a_935
      )
  
  instance AST.Unmarshal.SymbolMatching UseList where
    matchedSymbols _ = [188]
    showFailure _ node_936 =
      "expected "
        GHC.Base.<> ( "use_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_936 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_936) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_937 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_938 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_939 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_940 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_937
          c1_938 = TreeSitter.Node.nodeStartPoint node_936
        TreeSitter.Node.TSPoint
          r2_939
          c2_940 = TreeSitter.Node.nodeEndPoint node_936
  
  deriving instance GHC.Classes.Eq a_941 => GHC.Classes.Eq (UseList a_941)
  
  deriving instance GHC.Classes.Ord a_942 => GHC.Classes.Ord (UseList a_942)
  
  deriving instance GHC.Show.Show a_943 => GHC.Show.Show (UseList a_943)
  
  instance AST.Unmarshal.Unmarshal UseList
  
  instance Data.Foldable.Foldable UseList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UseList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UseList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VariableName a = VariableName
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Name a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_944.
        AST.Traversable1.Class.Traversable1 a_944
      )
  
  instance AST.Unmarshal.SymbolMatching VariableName where
    matchedSymbols _ = [269]
    showFailure _ node_945 =
      "expected "
        GHC.Base.<> ( "variable_name"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_945 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_945) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_946 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_947 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_948 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_949 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_946
          c1_947 = TreeSitter.Node.nodeStartPoint node_945
        TreeSitter.Node.TSPoint
          r2_948
          c2_949 = TreeSitter.Node.nodeEndPoint node_945
  
  deriving instance GHC.Classes.Eq a_950 => GHC.Classes.Eq (VariableName a_950)
  
  deriving instance GHC.Classes.Ord a_951 => GHC.Classes.Ord (VariableName a_951)
  
  deriving instance GHC.Show.Show a_952 => GHC.Show.Show (VariableName a_952)
  
  instance AST.Unmarshal.Unmarshal VariableName
  
  instance Data.Foldable.Foldable VariableName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VariableName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VariableName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VariadicParameter a = VariadicParameter
    { ann :: a,
      name :: (AST.Parse.Err (VariableName a)),
      type' :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_953.
        AST.Traversable1.Class.Traversable1 a_953
      )
  
  instance AST.Unmarshal.SymbolMatching VariadicParameter where
    matchedSymbols _ = [196]
    showFailure _ node_954 =
      "expected "
        GHC.Base.<> ( "variadic_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_954 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_954) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_955 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_956 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_957 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_958 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_955
          c1_956 = TreeSitter.Node.nodeStartPoint node_954
        TreeSitter.Node.TSPoint
          r2_957
          c2_958 = TreeSitter.Node.nodeEndPoint node_954
  
  deriving instance GHC.Classes.Eq a_959 => GHC.Classes.Eq (VariadicParameter a_959)
  
  deriving instance GHC.Classes.Ord a_960 => GHC.Classes.Ord (VariadicParameter a_960)
  
  deriving instance GHC.Show.Show a_961 => GHC.Show.Show (VariadicParameter a_961)
  
  instance AST.Unmarshal.Unmarshal VariadicParameter
  
  instance Data.Foldable.Foldable VariadicParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VariadicParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VariadicParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VariadicUnpacking a = VariadicUnpacking
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_962.
        AST.Traversable1.Class.Traversable1 a_962
      )
  
  instance AST.Unmarshal.SymbolMatching VariadicUnpacking where
    matchedSymbols _ = [263]
    showFailure _ node_963 =
      "expected "
        GHC.Base.<> ( "variadic_unpacking"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_963 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_963) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_964 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_965 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_966 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_967 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_964
          c1_965 = TreeSitter.Node.nodeStartPoint node_963
        TreeSitter.Node.TSPoint
          r2_966
          c2_967 = TreeSitter.Node.nodeEndPoint node_963
  
  deriving instance GHC.Classes.Eq a_968 => GHC.Classes.Eq (VariadicUnpacking a_968)
  
  deriving instance GHC.Classes.Ord a_969 => GHC.Classes.Ord (VariadicUnpacking a_969)
  
  deriving instance GHC.Show.Show a_970 => GHC.Show.Show (VariadicUnpacking a_970)
  
  instance AST.Unmarshal.Unmarshal VariadicUnpacking
  
  instance Data.Foldable.Foldable VariadicUnpacking where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VariadicUnpacking where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VariadicUnpacking where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data VisibilityModifier a = VisibilityModifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_971.
        AST.Traversable1.Class.Traversable1 a_971
      )
  
  instance AST.Unmarshal.SymbolMatching VisibilityModifier where
    matchedSymbols _ = [191]
    showFailure _ node_972 =
      "expected "
        GHC.Base.<> ( "visibility_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_972 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_972) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_973 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_974 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_975 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_976 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_973
          c1_974 = TreeSitter.Node.nodeStartPoint node_972
        TreeSitter.Node.TSPoint
          r2_975
          c2_976 = TreeSitter.Node.nodeEndPoint node_972
  
  deriving instance GHC.Classes.Eq a_977 => GHC.Classes.Eq (VisibilityModifier a_977)
  
  deriving instance GHC.Classes.Ord a_978 => GHC.Classes.Ord (VisibilityModifier a_978)
  
  deriving instance GHC.Show.Show a_979 => GHC.Show.Show (VisibilityModifier a_979)
  
  instance AST.Unmarshal.Unmarshal VisibilityModifier
  
  instance Data.Foldable.Foldable VisibilityModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VisibilityModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VisibilityModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WhileStatement a = WhileStatement
    { ann :: a,
      body :: (AST.Parse.Err ((Statement GHC.Generics.:+: ColonBlock) a)),
      condition :: (AST.Parse.Err (ParenthesizedExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_980.
        AST.Traversable1.Class.Traversable1 a_980
      )
  
  instance AST.Unmarshal.SymbolMatching WhileStatement where
    matchedSymbols _ = [216]
    showFailure _ node_981 =
      "expected "
        GHC.Base.<> ( "while_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_981 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_981) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_982 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_983 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_984 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_985 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_982
          c1_983 = TreeSitter.Node.nodeStartPoint node_981
        TreeSitter.Node.TSPoint
          r2_984
          c2_985 = TreeSitter.Node.nodeEndPoint node_981
  
  deriving instance GHC.Classes.Eq a_986 => GHC.Classes.Eq (WhileStatement a_986)
  
  deriving instance GHC.Classes.Ord a_987 => GHC.Classes.Ord (WhileStatement a_987)
  
  deriving instance GHC.Show.Show a_988 => GHC.Show.Show (WhileStatement a_988)
  
  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 YieldExpression a = YieldExpression
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: ArrayElementInitializer) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_989.
        AST.Traversable1.Class.Traversable1 a_989
      )
  
  instance AST.Unmarshal.SymbolMatching YieldExpression where
    matchedSymbols _ = [270]
    showFailure _ node_990 =
      "expected "
        GHC.Base.<> ( "yield_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_990 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_990) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_991 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_992 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_993 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_994 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_991
          c1_992 = TreeSitter.Node.nodeStartPoint node_990
        TreeSitter.Node.TSPoint
          r2_993
          c2_994 = TreeSitter.Node.nodeEndPoint node_990
  
  deriving instance GHC.Classes.Eq a_995 => GHC.Classes.Eq (YieldExpression a_995)
  
  deriving instance GHC.Classes.Ord a_996 => GHC.Classes.Ord (YieldExpression a_996)
  
  deriving instance GHC.Show.Show a_997 => GHC.Show.Show (YieldExpression a_997)
  
  instance AST.Unmarshal.Unmarshal YieldExpression
  
  instance Data.Foldable.Foldable YieldExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor YieldExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable YieldExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBang = AST.Token.Token "!" 88
  
  type AnonymousBangEqual = AST.Token.Token "!=" 131
  
  type AnonymousBangEqualEqual = AST.Token.Token "!==" 134
  
  type AnonymousDollar = AST.Token.Token "$" 118
  
  type AnonymousPercent = AST.Token.Token "%" 145
  
  type AnonymousPercentEqual = AST.Token.Token "%=" 100
  
  type AnonymousAmpersand = AST.Token.Token "&" 31
  
  type AnonymousAmpersandAmpersand = AST.Token.Token "&&" 127
  
  type AnonymousAmpersandEqual = AST.Token.Token "&=" 106
  
  type AnonymousLParen = AST.Token.Token "(" 32
  
  type AnonymousRParen = AST.Token.Token ")" 33
  
  type AnonymousStar = AST.Token.Token "*" 143
  
  type AnonymousStarStar = AST.Token.Token "**" 89
  
  type AnonymousStarStarEqual = AST.Token.Token "**=" 97
  
  type AnonymousStarEqual = AST.Token.Token "*=" 98
  
  type AnonymousPlus = AST.Token.Token "+" 85
  
  type AnonymousPlusPlus = AST.Token.Token "++" 94
  
  type AnonymousPlusEqual = AST.Token.Token "+=" 101
  
  type AnonymousComma = AST.Token.Token "," 8
  
  type AnonymousMinus = AST.Token.Token "-" 86
  
  type AnonymousMinusMinus = AST.Token.Token "--" 95
  
  type AnonymousMinusEqual = AST.Token.Token "-=" 102
  
  type AnonymousMinusRAngle = AST.Token.Token "->" 109
  
  type AnonymousDot = AST.Token.Token "." 142
  
  type AnonymousDotDotDot = AST.Token.Token "..." 34
  
  type AnonymousDotEqual = AST.Token.Token ".=" 103
  
  type AnonymousSlash = AST.Token.Token "/" 144
  
  type AnonymousSlashEqual = AST.Token.Token "/=" 99
  
  type AnonymousColon = AST.Token.Token ":" 51
  
  type AnonymousColonColon = AST.Token.Token "::" 91
  
  type AnonymousSemicolon = AST.Token.Token ";" 6
  
  type AnonymousLAngle = AST.Token.Token "<" 135
  
  type AnonymousLAngleLAngle = AST.Token.Token "<<" 140
  
  type AnonymousLAngleLAngleEqual = AST.Token.Token "<<=" 104
  
  type AnonymousLAngleEqual = AST.Token.Token "<=" 137
  
  type AnonymousLAngleEqualRAngle = AST.Token.Token "<=>" 139
  
  type AnonymousLAngleRAngle = AST.Token.Token "<>" 132
  
  type AnonymousEqual = AST.Token.Token "=" 9
  
  type AnonymousEqualEqual = AST.Token.Token "==" 130
  
  type AnonymousEqualEqualEqual = AST.Token.Token "===" 133
  
  type AnonymousEqualRAngle = AST.Token.Token "=>" 75
  
  type AnonymousRAngle = AST.Token.Token ">" 136
  
  type AnonymousRAngleEqual = AST.Token.Token ">=" 138
  
  type AnonymousRAngleRAngle = AST.Token.Token ">>" 141
  
  type AnonymousRAngleRAngleEqual = AST.Token.Token ">>=" 105
  
  type AnonymousQuestion = AST.Token.Token "?" 35
  
  type AnonymousQuestionRAngle = AST.Token.Token "?>" 3
  
  type AnonymousQuestionQuestion = AST.Token.Token "??" 122
  
  type AnonymousAt = AST.Token.Token "@" 84
  
  type AnonymousLBracket = AST.Token.Token "[" 113
  
  type AnonymousBackslash = AST.Token.Token "\\" 13
  
  type AnonymousRBracket = AST.Token.Token "]" 114
  
  type AnonymousCaret = AST.Token.Token "^" 129
  
  type AnonymousCaretEqual = AST.Token.Token "^=" 107
  
  type AnonymousAbstract = AST.Token.Token "abstract" 23
  
  type AnonymousAnd = AST.Token.Token "and" 123
  
  type AnonymousArray = AST.Token.Token "array" 36
  
  type AnonymousAs = AST.Token.Token "as" 16
  
  type AnonymousBinary = AST.Token.Token "binary" 44
  
  type AnonymousBool = AST.Token.Token "bool" 39
  
  data Boolean a = Boolean {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_998.
        AST.Traversable1.Class.Traversable1 a_998
      )
  
  instance AST.Unmarshal.SymbolMatching Boolean where
    matchedSymbols _ = [116]
    showFailure _ node_999 =
      "expected "
        GHC.Base.<> ( "boolean"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_999 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_999) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1000 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1001 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1002 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1003 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1000
          c1_1001 = TreeSitter.Node.nodeStartPoint node_999
        TreeSitter.Node.TSPoint
          r2_1002
          c2_1003 = TreeSitter.Node.nodeEndPoint node_999
  
  deriving instance GHC.Classes.Eq a_1004 => GHC.Classes.Eq (Boolean a_1004)
  
  deriving instance GHC.Classes.Ord a_1005 => GHC.Classes.Ord (Boolean a_1005)
  
  deriving instance GHC.Show.Show a_1006 => GHC.Show.Show (Boolean a_1006)
  
  instance AST.Unmarshal.Unmarshal Boolean
  
  instance Data.Foldable.Foldable Boolean where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Boolean where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Boolean where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBoolean = AST.Token.Token "boolean" 45
  
  type AnonymousBreak = AST.Token.Token "break" 64
  
  type AnonymousCallable = AST.Token.Token "callable" 37
  
  type AnonymousCase = AST.Token.Token "case" 82
  
  type AnonymousCatch = AST.Token.Token "catch" 60
  
  type AnonymousClass = AST.Token.Token "class" 22
  
  type AnonymousClone = AST.Token.Token "clone" 90
  
  type AnonymousConst = AST.Token.Token "const" 15
  
  type AnonymousContinue = AST.Token.Token "continue" 63
  
  type AnonymousDeclare = AST.Token.Token "declare" 53
  
  type AnonymousDefault = AST.Token.Token "default" 83
  
  type AnonymousDo = AST.Token.Token "do" 70
  
  type AnonymousDouble = AST.Token.Token "double" 46
  
  type AnonymousEcho = AST.Token.Token "echo" 52
  
  type AnonymousElse = AST.Token.Token "else" 79
  
  type AnonymousElseif = AST.Token.Token "elseif" 78
  
  type AnonymousEncoding = AST.Token.Token "encoding" 56
  
  type AnonymousEnddeclare = AST.Token.Token "enddeclare" 54
  
  type AnonymousEndfor = AST.Token.Token "endfor" 72
  
  type AnonymousEndforeach = AST.Token.Token "endforeach" 74
  
  type AnonymousEndif = AST.Token.Token "endif" 77
  
  type AnonymousEndswitch = AST.Token.Token "endswitch" 81
  
  type AnonymousEndwhile = AST.Token.Token "endwhile" 69
  
  type AnonymousExtends = AST.Token.Token "extends" 21
  
  type AnonymousFinal = AST.Token.Token "final" 24
  
  type AnonymousFinally = AST.Token.Token "finally" 61
  
  type AnonymousFloat = AST.Token.Token "float" 40
  
  data Float a = Float {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1007.
        AST.Traversable1.Class.Traversable1 a_1007
      )
  
  instance AST.Unmarshal.SymbolMatching Float where
    matchedSymbols _ = [58]
    showFailure _ node_1008 =
      "expected "
        GHC.Base.<> ( "float"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1008 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1008) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1009 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1010 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1011 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1012 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1009
          c1_1010 = TreeSitter.Node.nodeStartPoint node_1008
        TreeSitter.Node.TSPoint
          r2_1011
          c2_1012 = TreeSitter.Node.nodeEndPoint node_1008
  
  deriving instance GHC.Classes.Eq a_1013 => GHC.Classes.Eq (Float a_1013)
  
  deriving instance GHC.Classes.Ord a_1014 => GHC.Classes.Ord (Float a_1014)
  
  deriving instance GHC.Show.Show a_1015 => GHC.Show.Show (Float a_1015)
  
  instance AST.Unmarshal.Unmarshal Float
  
  instance Data.Foldable.Foldable Float where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Float where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Float where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousFor = AST.Token.Token "for" 71
  
  type AnonymousForeach = AST.Token.Token "foreach" 73
  
  type AnonymousFrom = AST.Token.Token "from" 120
  
  type AnonymousFunction = AST.Token.Token "function" 14
  
  type AnonymousGlobal = AST.Token.Token "global" 10
  
  type AnonymousGoto = AST.Token.Token "goto" 62
  
  data Heredoc a = Heredoc {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1016.
        AST.Traversable1.Class.Traversable1 a_1016
      )
  
  instance AST.Unmarshal.SymbolMatching Heredoc where
    matchedSymbols _ = [152]
    showFailure _ node_1017 =
      "expected "
        GHC.Base.<> ( "heredoc"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1017 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1017) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1018 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1019 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1020 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1021 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1018
          c1_1019 = TreeSitter.Node.nodeStartPoint node_1017
        TreeSitter.Node.TSPoint
          r2_1020
          c2_1021 = TreeSitter.Node.nodeEndPoint node_1017
  
  deriving instance GHC.Classes.Eq a_1022 => GHC.Classes.Eq (Heredoc a_1022)
  
  deriving instance GHC.Classes.Ord a_1023 => GHC.Classes.Ord (Heredoc a_1023)
  
  deriving instance GHC.Show.Show a_1024 => GHC.Show.Show (Heredoc a_1024)
  
  instance AST.Unmarshal.Unmarshal Heredoc
  
  instance Data.Foldable.Foldable Heredoc where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Heredoc where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Heredoc where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousIf = AST.Token.Token "if" 76
  
  type AnonymousImplements = AST.Token.Token "implements" 25
  
  type AnonymousInclude = AST.Token.Token "include" 146
  
  type AnonymousIncludeOnce = AST.Token.Token "include_once" 147
  
  type AnonymousInstanceof = AST.Token.Token "instanceof" 121
  
  type AnonymousInsteadof = AST.Token.Token "insteadof" 27
  
  type AnonymousInt = AST.Token.Token "int" 41
  
  type AnonymousInteger = AST.Token.Token "integer" 47
  
  data Integer a = Integer {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1025.
        AST.Traversable1.Class.Traversable1 a_1025
      )
  
  instance AST.Unmarshal.SymbolMatching Integer where
    matchedSymbols _ = [65]
    showFailure _ node_1026 =
      "expected "
        GHC.Base.<> ( "integer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1026 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1026) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1027 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1028 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1029 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1030 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1027
          c1_1028 = TreeSitter.Node.nodeStartPoint node_1026
        TreeSitter.Node.TSPoint
          r2_1029
          c2_1030 = TreeSitter.Node.nodeEndPoint node_1026
  
  deriving instance GHC.Classes.Eq a_1031 => GHC.Classes.Eq (Integer a_1031)
  
  deriving instance GHC.Classes.Ord a_1032 => GHC.Classes.Ord (Integer a_1032)
  
  deriving instance GHC.Show.Show a_1033 => GHC.Show.Show (Integer a_1033)
  
  instance AST.Unmarshal.Unmarshal Integer
  
  instance Data.Foldable.Foldable Integer where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Integer where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Integer where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousInterface = AST.Token.Token "interface" 20
  
  type AnonymousIterable = AST.Token.Token "iterable" 38
  
  type AnonymousList = AST.Token.Token "list" 110
  
  type AnonymousNamespace = AST.Token.Token "namespace" 11
  
  type AnonymousNew = AST.Token.Token "new" 93
  
  data Null a = Null {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1034.
        AST.Traversable1.Class.Traversable1 a_1034
      )
  
  instance AST.Unmarshal.SymbolMatching Null where
    matchedSymbols _ = [117]
    showFailure _ node_1035 =
      "expected "
        GHC.Base.<> ( "null"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1035 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1035) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1036 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1037 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1038 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1039 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1036
          c1_1037 = TreeSitter.Node.nodeStartPoint node_1035
        TreeSitter.Node.TSPoint
          r2_1038
          c2_1039 = TreeSitter.Node.nodeEndPoint node_1035
  
  deriving instance GHC.Classes.Eq a_1040 => GHC.Classes.Eq (Null a_1040)
  
  deriving instance GHC.Classes.Ord a_1041 => GHC.Classes.Ord (Null a_1041)
  
  deriving instance GHC.Show.Show a_1042 => GHC.Show.Show (Null a_1042)
  
  instance AST.Unmarshal.Unmarshal Null
  
  instance Data.Foldable.Foldable Null where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Null where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Null where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousObject = AST.Token.Token "object" 48
  
  type AnonymousOr = AST.Token.Token "or" 124
  
  type AnonymousParent = AST.Token.Token "parent" 112
  
  data PhpTag a = PhpTag {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1043.
        AST.Traversable1.Class.Traversable1 a_1043
      )
  
  instance AST.Unmarshal.SymbolMatching PhpTag where
    matchedSymbols _ = [2]
    showFailure _ node_1044 =
      "expected "
        GHC.Base.<> ( "php_tag"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1044 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1044) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1045 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1046 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1047 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1048 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1045
          c1_1046 = TreeSitter.Node.nodeStartPoint node_1044
        TreeSitter.Node.TSPoint
          r2_1047
          c2_1048 = TreeSitter.Node.nodeEndPoint node_1044
  
  deriving instance GHC.Classes.Eq a_1049 => GHC.Classes.Eq (PhpTag a_1049)
  
  deriving instance GHC.Classes.Ord a_1050 => GHC.Classes.Ord (PhpTag a_1050)
  
  deriving instance GHC.Show.Show a_1051 => GHC.Show.Show (PhpTag a_1051)
  
  instance AST.Unmarshal.Unmarshal PhpTag
  
  instance Data.Foldable.Foldable PhpTag where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PhpTag where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PhpTag where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousPrint = AST.Token.Token "print" 92
  
  type AnonymousPrivate = AST.Token.Token "private" 30
  
  type AnonymousProtected = AST.Token.Token "protected" 29
  
  type AnonymousPublic = AST.Token.Token "public" 28
  
  type AnonymousReal = AST.Token.Token "real" 49
  
  type AnonymousRequire = AST.Token.Token "require" 148
  
  type AnonymousRequireOnce = AST.Token.Token "require_once" 149
  
  type AnonymousReturn = AST.Token.Token "return" 66
  
  type AnonymousSelf = AST.Token.Token "self" 111
  
  data ShellCommandExpression a = ShellCommandExpression
    { ann :: a,
      text :: Data.Text.Internal.Text
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1052.
        AST.Traversable1.Class.Traversable1 a_1052
      )
  
  instance AST.Unmarshal.SymbolMatching ShellCommandExpression where
    matchedSymbols _ = [96]
    showFailure _ node_1053 =
      "expected "
        GHC.Base.<> ( "shell_command_expression"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1053 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1053) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1054 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1055 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1056 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1057 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1054
          c1_1055 = TreeSitter.Node.nodeStartPoint node_1053
        TreeSitter.Node.TSPoint
          r2_1056
          c2_1057 = TreeSitter.Node.nodeEndPoint node_1053
  
  deriving instance GHC.Classes.Eq a_1058 => GHC.Classes.Eq (ShellCommandExpression a_1058)
  
  deriving instance GHC.Classes.Ord a_1059 => GHC.Classes.Ord (ShellCommandExpression a_1059)
  
  deriving instance GHC.Show.Show a_1060 => GHC.Show.Show (ShellCommandExpression a_1060)
  
  instance AST.Unmarshal.Unmarshal ShellCommandExpression
  
  instance Data.Foldable.Foldable ShellCommandExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ShellCommandExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ShellCommandExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousStatic = AST.Token.Token "static" 7
  
  type AnonymousStrictTypes = AST.Token.Token "strict_types" 57
  
  type AnonymousString = AST.Token.Token "string" 42
  
  data String a = String {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1061.
        AST.Traversable1.Class.Traversable1 a_1061
      )
  
  instance AST.Unmarshal.SymbolMatching String where
    matchedSymbols _ = [115]
    showFailure _ node_1062 =
      "expected "
        GHC.Base.<> ( "string"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1062 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1062) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1063 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1064 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1065 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1066 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1063
          c1_1064 = TreeSitter.Node.nodeStartPoint node_1062
        TreeSitter.Node.TSPoint
          r2_1065
          c2_1066 = TreeSitter.Node.nodeEndPoint node_1062
  
  deriving instance GHC.Classes.Eq a_1067 => GHC.Classes.Eq (String a_1067)
  
  deriving instance GHC.Classes.Ord a_1068 => GHC.Classes.Ord (String a_1068)
  
  deriving instance GHC.Show.Show a_1069 => GHC.Show.Show (String a_1069)
  
  instance AST.Unmarshal.Unmarshal String
  
  instance Data.Foldable.Foldable String where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor String where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable String where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousSwitch = AST.Token.Token "switch" 80
  
  type AnonymousThrow = AST.Token.Token "throw" 67
  
  type AnonymousTicks = AST.Token.Token "ticks" 55
  
  type AnonymousTrait = AST.Token.Token "trait" 19
  
  type AnonymousTry = AST.Token.Token "try" 59
  
  type AnonymousUnset = AST.Token.Token "unset" 50
  
  type AnonymousUse = AST.Token.Token "use" 12
  
  data VarModifier a = VarModifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_1070.
        AST.Traversable1.Class.Traversable1 a_1070
      )
  
  instance AST.Unmarshal.SymbolMatching VarModifier where
    matchedSymbols _ = [26]
    showFailure _ node_1071 =
      "expected "
        GHC.Base.<> ( "var_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1071 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1071) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1072 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1073 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1074 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1075 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_1072
          c1_1073 = TreeSitter.Node.nodeStartPoint node_1071
        TreeSitter.Node.TSPoint
          r2_1074
          c2_1075 = TreeSitter.Node.nodeEndPoint node_1071
  
  deriving instance GHC.Classes.Eq a_1076 => GHC.Classes.Eq (VarModifier a_1076)
  
  deriving instance GHC.Classes.Ord a_1077 => GHC.Classes.Ord (VarModifier a_1077)
  
  deriving instance GHC.Show.Show a_1078 => GHC.Show.Show (VarModifier a_1078)
  
  instance AST.Unmarshal.Unmarshal VarModifier
  
  instance Data.Foldable.Foldable VarModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor VarModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable VarModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousVoid = AST.Token.Token "void" 43
  
  type AnonymousWhile = AST.Token.Token "while" 68
  
  type AnonymousXor = AST.Token.Token "xor" 125
  
  type AnonymousYield = AST.Token.Token "yield" 119
  
  type AnonymousLBrace = AST.Token.Token "{" 17
  
  type AnonymousPipe = AST.Token.Token "|" 128
  
  type AnonymousPipeEqual = AST.Token.Token "|=" 108
  
  type AnonymousPipePipe = AST.Token.Token "||" 126
  
  type AnonymousRBrace = AST.Token.Token "}" 18
  
  type AnonymousTilde = AST.Token.Token "~" 87
  