content: -- Language definition for Python, 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.Python.AST (module Language.Python.AST, getTestCorpusDir) where
  
  import qualified AST.Parse
  import qualified AST.Token
  import qualified AST.Traversable1.Class
  import qualified AST.Unmarshal
  import qualified Data.Foldable
  import qualified Data.List as Data.OldList
  import qualified Data.Maybe as GHC.Maybe
  import qualified Data.Text.Internal
  import qualified Data.Traversable
  import qualified GHC.Base
  import qualified GHC.Generics
  import qualified GHC.Records
  import qualified GHC.Show
  import qualified TreeSitter.Node
  import TreeSitter.Python (getTestCorpusDir)
  import qualified Prelude as GHC.Classes
  
  debugSymbolNames :: [GHC.Base.String]
  debugSymbolNames = debugSymbolNames_0
  
  debugSymbolNames_0 :: [GHC.Base.String]
  debugSymbolNames_0 =
    [ "end",
      "identifier",
      "_import",
      "_.",
      "_from",
      "___future__",
      "_(",
      "_)",
      "_,",
      "_as",
      "_*",
      "_print",
      "_>>",
      "_assert",
      "_:=",
      "_return",
      "_del",
      "_raise",
      "_pass",
      "_break",
      "_continue",
      "_if",
      "_:",
      "_elif",
      "_else",
      "_async",
      "_for",
      "_in",
      "_while",
      "_try",
      "_except",
      "_finally",
      "_with",
      "_def",
      "_->",
      "_=",
      "_**",
      "_global",
      "_nonlocal",
      "_exec",
      "_class",
      "_@",
      "_not",
      "_and",
      "_or",
      "_+",
      "_-",
      "_/",
      "_%",
      "_//",
      "_|",
      "_&",
      "_^",
      "_<<",
      "_~",
      "_<",
      "_<=",
      "_==",
      "_!=",
      "_>=",
      "_>",
      "_<>",
      "_is",
      "_lambda",
      "_+=",
      "_-=",
      "_*=",
      "_/=",
      "_@=",
      "_//=",
      "_%=",
      "_**=",
      "_>>=",
      "_<<=",
      "_&=",
      "_^=",
      "_|=",
      "_yield",
      "_[",
      "_]",
      "ellipsis",
      "_{",
      "_}",
      "escape_sequence",
      "_not_escape_sequence",
      "_format_specifier_token1",
      "type_conversion",
      "integer",
      "float",
      "true",
      "false",
      "none",
      "_await",
      "comment",
      "_semicolon",
      "_newline",
      "_indent",
      "_dedent",
      "_\"",
      "_string_content",
      "_\"",
      "module",
      "_statement",
      "_simple_statements",
      "import_statement",
      "import_prefix",
      "relative_import",
      "future_import_statement",
      "import_from_statement",
      "_import_list",
      "aliased_import",
      "wildcard_import",
      "print_statement",
      "chevron",
      "assert_statement",
      "expression_statement",
      "named_expression",
      "return_statement",
      "delete_statement",
      "raise_statement",
      "pass_statement",
      "break_statement",
      "continue_statement",
      "if_statement",
      "elif_clause",
      "else_clause",
      "for_statement",
      "while_statement",
      "try_statement",
      "except_clause",
      "finally_clause",
      "with_statement",
      "with_item",
      "function_definition",
      "parameters",
      "lambda_parameters",
      "_parameters",
      "default_parameter",
      "typed_default_parameter",
      "list_splat",
      "dictionary_splat",
      "global_statement",
      "nonlocal_statement",
      "exec_statement",
      "class_definition",
      "parenthesized_expression",
      "argument_list",
      "decorated_definition",
      "decorator",
      "block",
      "variables",
      "expression_list",
      "dotted_name",
      "_expression_within_for_in_clause",
      "_expression",
      "_primary_expression",
      "not_operator",
      "boolean_operator",
      "binary_operator",
      "unary_operator",
      "comparison_operator",
      "lambda",
      "lambda",
      "assignment",
      "augmented_assignment",
      "_right_hand_side",
      "yield",
      "attribute",
      "subscript",
      "slice",
      "call",
      "typed_parameter",
      "type",
      "keyword_argument",
      "list",
      "_comprehension_clauses",
      "list_comprehension",
      "dictionary",
      "dictionary_comprehension",
      "pair",
      "set",
      "set_comprehension",
      "parenthesized_expression",
      "tuple",
      "generator_expression",
      "for_in_clause",
      "if_clause",
      "conditional_expression",
      "concatenated_string",
      "string",
      "interpolation",
      "format_specifier",
      "format_expression",
      "await",
      "_module_repeat1",
      "__simple_statements_repeat1",
      "_import_prefix_repeat1",
      "__import_list_repeat1",
      "_print_statement_repeat1",
      "_assert_statement_repeat1",
      "_if_statement_repeat1",
      "_try_statement_repeat1",
      "_with_statement_repeat1",
      "__parameters_repeat1",
      "_global_statement_repeat1",
      "_argument_list_repeat1",
      "_decorated_definition_repeat1",
      "_variables_repeat1",
      "_dotted_name_repeat1",
      "_comparison_operator_repeat1",
      "_subscript_repeat1",
      "_list_repeat1",
      "__comprehension_clauses_repeat1",
      "_dictionary_repeat1",
      "_tuple_repeat1",
      "_for_in_clause_repeat1",
      "_concatenated_string_repeat1",
      "_string_repeat1",
      "_format_specifier_repeat1"
    ]
  
  newtype CompoundStatement a = CompoundStatement {getCompoundStatement :: ((ClassDefinition GHC.Generics.:+: DecoratedDefinition GHC.Generics.:+: ForStatement GHC.Generics.:+: FunctionDefinition GHC.Generics.:+: IfStatement GHC.Generics.:+: TryStatement GHC.Generics.:+: WhileStatement GHC.Generics.:+: WithStatement) 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" (CompoundStatement a_2) a_2 where
    getField = AST.Unmarshal.gann GHC.Base.. getCompoundStatement
  
  deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (CompoundStatement a_3)
  
  deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (CompoundStatement a_4)
  
  deriving instance GHC.Show.Show a_5 => GHC.Show.Show (CompoundStatement a_5)
  
  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
  
  newtype Expression a = Expression {getExpression :: ((PrimaryExpression GHC.Generics.:+: Await GHC.Generics.:+: BooleanOperator GHC.Generics.:+: ComparisonOperator GHC.Generics.:+: ConditionalExpression GHC.Generics.:+: Lambda GHC.Generics.:+: NamedExpression GHC.Generics.:+: NotOperator) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_6.
        AST.Traversable1.Class.Traversable1 a_6
      )
  
  instance GHC.Records.HasField "ann" (Expression a_7) a_7 where
    getField = AST.Unmarshal.gann GHC.Base.. getExpression
  
  deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (Expression a_8)
  
  deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (Expression a_9)
  
  deriving instance GHC.Show.Show a_10 => GHC.Show.Show (Expression a_10)
  
  instance AST.Unmarshal.Unmarshal Expression
  
  instance Data.Foldable.Foldable Expression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Expression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Expression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Parameter a = Parameter {getParameter :: ((DefaultParameter GHC.Generics.:+: DictionarySplat GHC.Generics.:+: Identifier GHC.Generics.:+: ListSplat GHC.Generics.:+: Tuple GHC.Generics.:+: TypedDefaultParameter GHC.Generics.:+: TypedParameter) 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" (Parameter a_12) a_12 where
    getField = AST.Unmarshal.gann GHC.Base.. getParameter
  
  deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (Parameter a_13)
  
  deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (Parameter a_14)
  
  deriving instance GHC.Show.Show a_15 => GHC.Show.Show (Parameter a_15)
  
  instance AST.Unmarshal.Unmarshal Parameter
  
  instance Data.Foldable.Foldable Parameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Parameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Parameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype PrimaryExpression a = PrimaryExpression {getPrimaryExpression :: ((Attribute GHC.Generics.:+: BinaryOperator GHC.Generics.:+: Call GHC.Generics.:+: ConcatenatedString GHC.Generics.:+: Dictionary GHC.Generics.:+: DictionaryComprehension GHC.Generics.:+: Ellipsis GHC.Generics.:+: False GHC.Generics.:+: Float GHC.Generics.:+: GeneratorExpression GHC.Generics.:+: Identifier GHC.Generics.:+: Integer GHC.Generics.:+: List GHC.Generics.:+: ListComprehension GHC.Generics.:+: None GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: Set GHC.Generics.:+: SetComprehension GHC.Generics.:+: String GHC.Generics.:+: Subscript GHC.Generics.:+: True GHC.Generics.:+: Tuple GHC.Generics.:+: UnaryOperator) 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" (PrimaryExpression a_17) a_17 where
    getField = AST.Unmarshal.gann GHC.Base.. getPrimaryExpression
  
  deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (PrimaryExpression a_18)
  
  deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (PrimaryExpression a_19)
  
  deriving instance GHC.Show.Show a_20 => GHC.Show.Show (PrimaryExpression a_20)
  
  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 SimpleStatement a = SimpleStatement {getSimpleStatement :: ((AssertStatement GHC.Generics.:+: BreakStatement GHC.Generics.:+: ContinueStatement GHC.Generics.:+: DeleteStatement GHC.Generics.:+: ExecStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: FutureImportStatement GHC.Generics.:+: GlobalStatement GHC.Generics.:+: ImportFromStatement GHC.Generics.:+: ImportStatement GHC.Generics.:+: NonlocalStatement GHC.Generics.:+: PassStatement GHC.Generics.:+: PrintStatement GHC.Generics.:+: RaiseStatement GHC.Generics.:+: ReturnStatement) 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" (SimpleStatement a_22) a_22 where
    getField = AST.Unmarshal.gann GHC.Base.. getSimpleStatement
  
  deriving instance GHC.Classes.Eq a_23 => GHC.Classes.Eq (SimpleStatement a_23)
  
  deriving instance GHC.Classes.Ord a_24 => GHC.Classes.Ord (SimpleStatement a_24)
  
  deriving instance GHC.Show.Show a_25 => GHC.Show.Show (SimpleStatement a_25)
  
  instance AST.Unmarshal.Unmarshal SimpleStatement
  
  instance Data.Foldable.Foldable SimpleStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SimpleStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SimpleStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AliasedImport a = AliasedImport
    { ann :: a,
      alias :: (AST.Parse.Err (Identifier a)),
      name :: (AST.Parse.Err (DottedName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_26.
        AST.Traversable1.Class.Traversable1 a_26
      )
  
  instance AST.Unmarshal.SymbolMatching AliasedImport where
    matchedSymbols _ = [110]
    showFailure _ node_27 =
      "expected "
        GHC.Base.<> ( "aliased_import"
                        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 (AliasedImport a_32)
  
  deriving instance GHC.Classes.Ord a_33 => GHC.Classes.Ord (AliasedImport a_33)
  
  deriving instance GHC.Show.Show a_34 => GHC.Show.Show (AliasedImport a_34)
  
  instance AST.Unmarshal.Unmarshal AliasedImport
  
  instance Data.Foldable.Foldable AliasedImport where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AliasedImport where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AliasedImport where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArgumentList a = ArgumentList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: DictionarySplat GHC.Generics.:+: KeywordArgument GHC.Generics.:+: ListSplat GHC.Generics.:+: ParenthesizedExpression) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_35.
        AST.Traversable1.Class.Traversable1 a_35
      )
  
  instance AST.Unmarshal.SymbolMatching ArgumentList where
    matchedSymbols _ = [146]
    showFailure _ node_36 =
      "expected "
        GHC.Base.<> ( "argument_list"
                        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 (ArgumentList a_41)
  
  deriving instance GHC.Classes.Ord a_42 => GHC.Classes.Ord (ArgumentList a_42)
  
  deriving instance GHC.Show.Show a_43 => GHC.Show.Show (ArgumentList a_43)
  
  instance AST.Unmarshal.Unmarshal ArgumentList
  
  instance Data.Foldable.Foldable ArgumentList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ArgumentList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ArgumentList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AssertStatement a = AssertStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_44.
        AST.Traversable1.Class.Traversable1 a_44
      )
  
  instance AST.Unmarshal.SymbolMatching AssertStatement where
    matchedSymbols _ = [114]
    showFailure _ node_45 =
      "expected "
        GHC.Base.<> ( "assert_statement"
                        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 (AssertStatement a_50)
  
  deriving instance GHC.Classes.Ord a_51 => GHC.Classes.Ord (AssertStatement a_51)
  
  deriving instance GHC.Show.Show a_52 => GHC.Show.Show (AssertStatement a_52)
  
  instance AST.Unmarshal.Unmarshal AssertStatement
  
  instance Data.Foldable.Foldable AssertStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AssertStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AssertStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Assignment a = Assignment
    { ann :: a,
      left :: (AST.Parse.Err (ExpressionList a)),
      right :: (GHC.Maybe.Maybe (AST.Parse.Err ((Assignment GHC.Generics.:+: AugmentedAssignment GHC.Generics.:+: ExpressionList GHC.Generics.:+: Yield) a))),
      type' :: (GHC.Maybe.Maybe (AST.Parse.Err (Type a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_53.
        AST.Traversable1.Class.Traversable1 a_53
      )
  
  instance AST.Unmarshal.SymbolMatching Assignment where
    matchedSymbols _ = [163]
    showFailure _ node_54 =
      "expected "
        GHC.Base.<> ( "assignment"
                        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 (Assignment a_59)
  
  deriving instance GHC.Classes.Ord a_60 => GHC.Classes.Ord (Assignment a_60)
  
  deriving instance GHC.Show.Show a_61 => GHC.Show.Show (Assignment a_61)
  
  instance AST.Unmarshal.Unmarshal Assignment
  
  instance Data.Foldable.Foldable Assignment where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Assignment where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Assignment where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Attribute a = Attribute
    { ann :: a,
      attribute :: (AST.Parse.Err (Identifier a)),
      object :: (AST.Parse.Err (PrimaryExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_62.
        AST.Traversable1.Class.Traversable1 a_62
      )
  
  instance AST.Unmarshal.SymbolMatching Attribute where
    matchedSymbols _ = [167]
    showFailure _ node_63 =
      "expected "
        GHC.Base.<> ( "attribute"
                        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 (Attribute a_68)
  
  deriving instance GHC.Classes.Ord a_69 => GHC.Classes.Ord (Attribute a_69)
  
  deriving instance GHC.Show.Show a_70 => GHC.Show.Show (Attribute a_70)
  
  instance AST.Unmarshal.Unmarshal Attribute
  
  instance Data.Foldable.Foldable Attribute where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Attribute where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Attribute where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data AugmentedAssignment a = AugmentedAssignment
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousPercentEqual GHC.Generics.:+: AnonymousAmpersandEqual GHC.Generics.:+: AnonymousStarStarEqual GHC.Generics.:+: AnonymousStarEqual GHC.Generics.:+: AnonymousPlusEqual GHC.Generics.:+: AnonymousMinusEqual GHC.Generics.:+: AnonymousSlashSlashEqual GHC.Generics.:+: AnonymousSlashEqual GHC.Generics.:+: AnonymousLAngleLAngleEqual GHC.Generics.:+: AnonymousRAngleRAngleEqual GHC.Generics.:+: AnonymousAtEqual GHC.Generics.:+: AnonymousCaretEqual GHC.Generics.:+: AnonymousPipeEqual) a)),
      left :: (AST.Parse.Err (ExpressionList a)),
      right :: (AST.Parse.Err ((Assignment GHC.Generics.:+: AugmentedAssignment GHC.Generics.:+: ExpressionList GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_71.
        AST.Traversable1.Class.Traversable1 a_71
      )
  
  instance AST.Unmarshal.SymbolMatching AugmentedAssignment where
    matchedSymbols _ = [164]
    showFailure _ node_72 =
      "expected "
        GHC.Base.<> ( "augmented_assignment"
                        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 (AugmentedAssignment a_77)
  
  deriving instance GHC.Classes.Ord a_78 => GHC.Classes.Ord (AugmentedAssignment a_78)
  
  deriving instance GHC.Show.Show a_79 => GHC.Show.Show (AugmentedAssignment a_79)
  
  instance AST.Unmarshal.Unmarshal AugmentedAssignment
  
  instance Data.Foldable.Foldable AugmentedAssignment where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor AugmentedAssignment where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable AugmentedAssignment where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Await a = Await {ann :: a, extraChildren :: (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 Await where
    matchedSymbols _ = [193]
    showFailure _ node_81 =
      "expected "
        GHC.Base.<> ( "await"
                        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 (Await a_86)
  
  deriving instance GHC.Classes.Ord a_87 => GHC.Classes.Ord (Await a_87)
  
  deriving instance GHC.Show.Show a_88 => GHC.Show.Show (Await a_88)
  
  instance AST.Unmarshal.Unmarshal Await
  
  instance Data.Foldable.Foldable Await where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Await where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Await where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BinaryOperator a = BinaryOperator
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousStarStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousSlashSlash GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousAt GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousPipe) a)),
      left :: (AST.Parse.Err (PrimaryExpression a)),
      right :: (AST.Parse.Err (PrimaryExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_89.
        AST.Traversable1.Class.Traversable1 a_89
      )
  
  instance AST.Unmarshal.SymbolMatching BinaryOperator where
    matchedSymbols _ = [158]
    showFailure _ node_90 =
      "expected "
        GHC.Base.<> ( "binary_operator"
                        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 (BinaryOperator a_95)
  
  deriving instance GHC.Classes.Ord a_96 => GHC.Classes.Ord (BinaryOperator a_96)
  
  deriving instance GHC.Show.Show a_97 => GHC.Show.Show (BinaryOperator a_97)
  
  instance AST.Unmarshal.Unmarshal BinaryOperator
  
  instance Data.Foldable.Foldable BinaryOperator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BinaryOperator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BinaryOperator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Block a = Block
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((CompoundStatement GHC.Generics.:+: SimpleStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_98.
        AST.Traversable1.Class.Traversable1 a_98
      )
  
  instance AST.Unmarshal.SymbolMatching Block where
    matchedSymbols _ = [149]
    showFailure _ node_99 =
      "expected "
        GHC.Base.<> ( "block"
                        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 (Block a_104)
  
  deriving instance GHC.Classes.Ord a_105 => GHC.Classes.Ord (Block a_105)
  
  deriving instance GHC.Show.Show a_106 => GHC.Show.Show (Block a_106)
  
  instance AST.Unmarshal.Unmarshal Block
  
  instance Data.Foldable.Foldable Block where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Block where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Block where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BooleanOperator a = BooleanOperator
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousAnd GHC.Generics.:+: AnonymousOr) a)),
      left :: (AST.Parse.Err (Expression a)),
      right :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_107.
        AST.Traversable1.Class.Traversable1 a_107
      )
  
  instance AST.Unmarshal.SymbolMatching BooleanOperator where
    matchedSymbols _ = [157]
    showFailure _ node_108 =
      "expected "
        GHC.Base.<> ( "boolean_operator"
                        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 (BooleanOperator a_113)
  
  deriving instance GHC.Classes.Ord a_114 => GHC.Classes.Ord (BooleanOperator a_114)
  
  deriving instance GHC.Show.Show a_115 => GHC.Show.Show (BooleanOperator a_115)
  
  instance AST.Unmarshal.Unmarshal BooleanOperator
  
  instance Data.Foldable.Foldable BooleanOperator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BooleanOperator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BooleanOperator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BreakStatement a = BreakStatement {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_116.
        AST.Traversable1.Class.Traversable1 a_116
      )
  
  instance AST.Unmarshal.SymbolMatching BreakStatement where
    matchedSymbols _ = [121]
    showFailure _ node_117 =
      "expected "
        GHC.Base.<> ( "break_statement"
                        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 (BreakStatement a_122)
  
  deriving instance GHC.Classes.Ord a_123 => GHC.Classes.Ord (BreakStatement a_123)
  
  deriving instance GHC.Show.Show a_124 => GHC.Show.Show (BreakStatement a_124)
  
  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 Call a = Call
    { ann :: a,
      function :: (AST.Parse.Err (PrimaryExpression a)),
      arguments :: (AST.Parse.Err ((ArgumentList GHC.Generics.:+: GeneratorExpression) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_125.
        AST.Traversable1.Class.Traversable1 a_125
      )
  
  instance AST.Unmarshal.SymbolMatching Call where
    matchedSymbols _ = [170]
    showFailure _ node_126 =
      "expected "
        GHC.Base.<> ( "call"
                        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 (Call a_131)
  
  deriving instance GHC.Classes.Ord a_132 => GHC.Classes.Ord (Call a_132)
  
  deriving instance GHC.Show.Show a_133 => GHC.Show.Show (Call a_133)
  
  instance AST.Unmarshal.Unmarshal Call
  
  instance Data.Foldable.Foldable Call where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Call where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Call where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Chevron a = Chevron
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_134.
        AST.Traversable1.Class.Traversable1 a_134
      )
  
  instance AST.Unmarshal.SymbolMatching Chevron where
    matchedSymbols _ = [113]
    showFailure _ node_135 =
      "expected "
        GHC.Base.<> ( "chevron"
                        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 (Chevron a_140)
  
  deriving instance GHC.Classes.Ord a_141 => GHC.Classes.Ord (Chevron a_141)
  
  deriving instance GHC.Show.Show a_142 => GHC.Show.Show (Chevron a_142)
  
  instance AST.Unmarshal.Unmarshal Chevron
  
  instance Data.Foldable.Foldable Chevron where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Chevron where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Chevron where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ClassDefinition a = ClassDefinition
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      superclasses :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a))),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_143.
        AST.Traversable1.Class.Traversable1 a_143
      )
  
  instance AST.Unmarshal.SymbolMatching ClassDefinition where
    matchedSymbols _ = [144]
    showFailure _ node_144 =
      "expected "
        GHC.Base.<> ( "class_definition"
                        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 (ClassDefinition a_149)
  
  deriving instance GHC.Classes.Ord a_150 => GHC.Classes.Ord (ClassDefinition a_150)
  
  deriving instance GHC.Show.Show a_151 => GHC.Show.Show (ClassDefinition a_151)
  
  instance AST.Unmarshal.Unmarshal ClassDefinition
  
  instance Data.Foldable.Foldable ClassDefinition where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassDefinition where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassDefinition where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ComparisonOperator a = ComparisonOperator
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (PrimaryExpression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_152.
        AST.Traversable1.Class.Traversable1 a_152
      )
  
  instance AST.Unmarshal.SymbolMatching ComparisonOperator where
    matchedSymbols _ = [160]
    showFailure _ node_153 =
      "expected "
        GHC.Base.<> ( "comparison_operator"
                        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 (ComparisonOperator a_158)
  
  deriving instance GHC.Classes.Ord a_159 => GHC.Classes.Ord (ComparisonOperator a_159)
  
  deriving instance GHC.Show.Show a_160 => GHC.Show.Show (ComparisonOperator a_160)
  
  instance AST.Unmarshal.Unmarshal ComparisonOperator
  
  instance Data.Foldable.Foldable ComparisonOperator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ComparisonOperator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ComparisonOperator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConcatenatedString a = ConcatenatedString
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (String a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_161.
        AST.Traversable1.Class.Traversable1 a_161
      )
  
  instance AST.Unmarshal.SymbolMatching ConcatenatedString where
    matchedSymbols _ = [188]
    showFailure _ node_162 =
      "expected "
        GHC.Base.<> ( "concatenated_string"
                        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 (ConcatenatedString a_167)
  
  deriving instance GHC.Classes.Ord a_168 => GHC.Classes.Ord (ConcatenatedString a_168)
  
  deriving instance GHC.Show.Show a_169 => GHC.Show.Show (ConcatenatedString a_169)
  
  instance AST.Unmarshal.Unmarshal ConcatenatedString
  
  instance Data.Foldable.Foldable ConcatenatedString where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ConcatenatedString where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ConcatenatedString where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ConditionalExpression a = ConditionalExpression
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_170.
        AST.Traversable1.Class.Traversable1 a_170
      )
  
  instance AST.Unmarshal.SymbolMatching ConditionalExpression where
    matchedSymbols _ = [187]
    showFailure _ node_171 =
      "expected "
        GHC.Base.<> ( "conditional_expression"
                        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 (ConditionalExpression a_176)
  
  deriving instance GHC.Classes.Ord a_177 => GHC.Classes.Ord (ConditionalExpression a_177)
  
  deriving instance GHC.Show.Show a_178 => GHC.Show.Show (ConditionalExpression a_178)
  
  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 ContinueStatement a = ContinueStatement {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 ContinueStatement where
    matchedSymbols _ = [122]
    showFailure _ node_180 =
      "expected "
        GHC.Base.<> ( "continue_statement"
                        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 (ContinueStatement a_185)
  
  deriving instance GHC.Classes.Ord a_186 => GHC.Classes.Ord (ContinueStatement a_186)
  
  deriving instance GHC.Show.Show a_187 => GHC.Show.Show (ContinueStatement a_187)
  
  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 DecoratedDefinition a = DecoratedDefinition
    { ann :: a,
      definition :: (AST.Parse.Err ((ClassDefinition GHC.Generics.:+: FunctionDefinition) a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Decorator a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_188.
        AST.Traversable1.Class.Traversable1 a_188
      )
  
  instance AST.Unmarshal.SymbolMatching DecoratedDefinition where
    matchedSymbols _ = [147]
    showFailure _ node_189 =
      "expected "
        GHC.Base.<> ( "decorated_definition"
                        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 (DecoratedDefinition a_194)
  
  deriving instance GHC.Classes.Ord a_195 => GHC.Classes.Ord (DecoratedDefinition a_195)
  
  deriving instance GHC.Show.Show a_196 => GHC.Show.Show (DecoratedDefinition a_196)
  
  instance AST.Unmarshal.Unmarshal DecoratedDefinition
  
  instance Data.Foldable.Foldable DecoratedDefinition where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DecoratedDefinition where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DecoratedDefinition where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Decorator a = Decorator
    { ann :: a,
      arguments :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a))),
      extraChildren :: (AST.Parse.Err (DottedName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_197.
        AST.Traversable1.Class.Traversable1 a_197
      )
  
  instance AST.Unmarshal.SymbolMatching Decorator where
    matchedSymbols _ = [148]
    showFailure _ node_198 =
      "expected "
        GHC.Base.<> ( "decorator"
                        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 (Decorator a_203)
  
  deriving instance GHC.Classes.Ord a_204 => GHC.Classes.Ord (Decorator a_204)
  
  deriving instance GHC.Show.Show a_205 => GHC.Show.Show (Decorator a_205)
  
  instance AST.Unmarshal.Unmarshal Decorator
  
  instance Data.Foldable.Foldable Decorator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Decorator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Decorator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DefaultParameter a = DefaultParameter
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_206.
        AST.Traversable1.Class.Traversable1 a_206
      )
  
  instance AST.Unmarshal.SymbolMatching DefaultParameter where
    matchedSymbols _ = [137]
    showFailure _ node_207 =
      "expected "
        GHC.Base.<> ( "default_parameter"
                        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 (DefaultParameter a_212)
  
  deriving instance GHC.Classes.Ord a_213 => GHC.Classes.Ord (DefaultParameter a_213)
  
  deriving instance GHC.Show.Show a_214 => GHC.Show.Show (DefaultParameter a_214)
  
  instance AST.Unmarshal.Unmarshal DefaultParameter
  
  instance Data.Foldable.Foldable DefaultParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DefaultParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DefaultParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DeleteStatement a = DeleteStatement
    { ann :: a,
      extraChildren :: (AST.Parse.Err (ExpressionList a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_215.
        AST.Traversable1.Class.Traversable1 a_215
      )
  
  instance AST.Unmarshal.SymbolMatching DeleteStatement where
    matchedSymbols _ = [118]
    showFailure _ node_216 =
      "expected "
        GHC.Base.<> ( "delete_statement"
                        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 (DeleteStatement a_221)
  
  deriving instance GHC.Classes.Ord a_222 => GHC.Classes.Ord (DeleteStatement a_222)
  
  deriving instance GHC.Show.Show a_223 => GHC.Show.Show (DeleteStatement a_223)
  
  instance AST.Unmarshal.Unmarshal DeleteStatement
  
  instance Data.Foldable.Foldable DeleteStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DeleteStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DeleteStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Dictionary a = Dictionary
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((DictionarySplat GHC.Generics.:+: Pair) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_224.
        AST.Traversable1.Class.Traversable1 a_224
      )
  
  instance AST.Unmarshal.SymbolMatching Dictionary where
    matchedSymbols _ = [177]
    showFailure _ node_225 =
      "expected "
        GHC.Base.<> ( "dictionary"
                        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 (Dictionary a_230)
  
  deriving instance GHC.Classes.Ord a_231 => GHC.Classes.Ord (Dictionary a_231)
  
  deriving instance GHC.Show.Show a_232 => GHC.Show.Show (Dictionary a_232)
  
  instance AST.Unmarshal.Unmarshal Dictionary
  
  instance Data.Foldable.Foldable Dictionary where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Dictionary where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Dictionary where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DictionaryComprehension a = DictionaryComprehension
    { ann :: a,
      body :: (AST.Parse.Err (Pair a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ForInClause GHC.Generics.:+: IfClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_233.
        AST.Traversable1.Class.Traversable1 a_233
      )
  
  instance AST.Unmarshal.SymbolMatching DictionaryComprehension where
    matchedSymbols _ = [178]
    showFailure _ node_234 =
      "expected "
        GHC.Base.<> ( "dictionary_comprehension"
                        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 (DictionaryComprehension a_239)
  
  deriving instance GHC.Classes.Ord a_240 => GHC.Classes.Ord (DictionaryComprehension a_240)
  
  deriving instance GHC.Show.Show a_241 => GHC.Show.Show (DictionaryComprehension a_241)
  
  instance AST.Unmarshal.Unmarshal DictionaryComprehension
  
  instance Data.Foldable.Foldable DictionaryComprehension where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DictionaryComprehension where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DictionaryComprehension where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DictionarySplat a = DictionarySplat
    { ann :: a,
      extraChildren :: (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 DictionarySplat where
    matchedSymbols _ = [140]
    showFailure _ node_243 =
      "expected "
        GHC.Base.<> ( "dictionary_splat"
                        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 (DictionarySplat a_248)
  
  deriving instance GHC.Classes.Ord a_249 => GHC.Classes.Ord (DictionarySplat a_249)
  
  deriving instance GHC.Show.Show a_250 => GHC.Show.Show (DictionarySplat a_250)
  
  instance AST.Unmarshal.Unmarshal DictionarySplat
  
  instance Data.Foldable.Foldable DictionarySplat where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DictionarySplat where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DictionarySplat where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DottedName a = DottedName
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_251.
        AST.Traversable1.Class.Traversable1 a_251
      )
  
  instance AST.Unmarshal.SymbolMatching DottedName where
    matchedSymbols _ = [152]
    showFailure _ node_252 =
      "expected "
        GHC.Base.<> ( "dotted_name"
                        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 (DottedName a_257)
  
  deriving instance GHC.Classes.Ord a_258 => GHC.Classes.Ord (DottedName a_258)
  
  deriving instance GHC.Show.Show a_259 => GHC.Show.Show (DottedName a_259)
  
  instance AST.Unmarshal.Unmarshal DottedName
  
  instance Data.Foldable.Foldable DottedName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DottedName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DottedName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElifClause a = ElifClause
    { ann :: a,
      consequence :: (AST.Parse.Err (Block a)),
      condition :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_260.
        AST.Traversable1.Class.Traversable1 a_260
      )
  
  instance AST.Unmarshal.SymbolMatching ElifClause where
    matchedSymbols _ = [124]
    showFailure _ node_261 =
      "expected "
        GHC.Base.<> ( "elif_clause"
                        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 (ElifClause a_266)
  
  deriving instance GHC.Classes.Ord a_267 => GHC.Classes.Ord (ElifClause a_267)
  
  deriving instance GHC.Show.Show a_268 => GHC.Show.Show (ElifClause a_268)
  
  instance AST.Unmarshal.Unmarshal ElifClause
  
  instance Data.Foldable.Foldable ElifClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElifClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElifClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElseClause a = ElseClause {ann :: a, body :: (AST.Parse.Err (Block a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_269.
        AST.Traversable1.Class.Traversable1 a_269
      )
  
  instance AST.Unmarshal.SymbolMatching ElseClause where
    matchedSymbols _ = [125]
    showFailure _ node_270 =
      "expected "
        GHC.Base.<> ( "else_clause"
                        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 (ElseClause a_275)
  
  deriving instance GHC.Classes.Ord a_276 => GHC.Classes.Ord (ElseClause a_276)
  
  deriving instance GHC.Show.Show a_277 => GHC.Show.Show (ElseClause a_277)
  
  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 ExceptClause a = ExceptClause
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Block) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_278.
        AST.Traversable1.Class.Traversable1 a_278
      )
  
  instance AST.Unmarshal.SymbolMatching ExceptClause where
    matchedSymbols _ = [129]
    showFailure _ node_279 =
      "expected "
        GHC.Base.<> ( "except_clause"
                        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 (ExceptClause a_284)
  
  deriving instance GHC.Classes.Ord a_285 => GHC.Classes.Ord (ExceptClause a_285)
  
  deriving instance GHC.Show.Show a_286 => GHC.Show.Show (ExceptClause a_286)
  
  instance AST.Unmarshal.Unmarshal ExceptClause
  
  instance Data.Foldable.Foldable ExceptClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExceptClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExceptClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExecStatement a = ExecStatement
    { ann :: a,
      code :: (AST.Parse.Err (String a)),
      extraChildren :: ([AST.Parse.Err (Expression a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_287.
        AST.Traversable1.Class.Traversable1 a_287
      )
  
  instance AST.Unmarshal.SymbolMatching ExecStatement where
    matchedSymbols _ = [143]
    showFailure _ node_288 =
      "expected "
        GHC.Base.<> ( "exec_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 (ExecStatement a_293)
  
  deriving instance GHC.Classes.Ord a_294 => GHC.Classes.Ord (ExecStatement a_294)
  
  deriving instance GHC.Show.Show a_295 => GHC.Show.Show (ExecStatement a_295)
  
  instance AST.Unmarshal.Unmarshal ExecStatement
  
  instance Data.Foldable.Foldable ExecStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExecStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExecStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExpressionList a = ExpressionList
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_296.
        AST.Traversable1.Class.Traversable1 a_296
      )
  
  instance AST.Unmarshal.SymbolMatching ExpressionList where
    matchedSymbols _ = [151]
    showFailure _ node_297 =
      "expected "
        GHC.Base.<> ( "expression_list"
                        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 (ExpressionList a_302)
  
  deriving instance GHC.Classes.Ord a_303 => GHC.Classes.Ord (ExpressionList a_303)
  
  deriving instance GHC.Show.Show a_304 => GHC.Show.Show (ExpressionList a_304)
  
  instance AST.Unmarshal.Unmarshal ExpressionList
  
  instance Data.Foldable.Foldable ExpressionList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExpressionList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExpressionList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExpressionStatement a = ExpressionStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: Assignment GHC.Generics.:+: AugmentedAssignment GHC.Generics.:+: Yield) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_305.
        AST.Traversable1.Class.Traversable1 a_305
      )
  
  instance AST.Unmarshal.SymbolMatching ExpressionStatement where
    matchedSymbols _ = [115]
    showFailure _ node_306 =
      "expected "
        GHC.Base.<> ( "expression_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 (ExpressionStatement a_311)
  
  deriving instance GHC.Classes.Ord a_312 => GHC.Classes.Ord (ExpressionStatement a_312)
  
  deriving instance GHC.Show.Show a_313 => GHC.Show.Show (ExpressionStatement a_313)
  
  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,
      extraChildren :: (AST.Parse.Err (Block a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_314.
        AST.Traversable1.Class.Traversable1 a_314
      )
  
  instance AST.Unmarshal.SymbolMatching FinallyClause where
    matchedSymbols _ = [130]
    showFailure _ node_315 =
      "expected "
        GHC.Base.<> ( "finally_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 (FinallyClause a_320)
  
  deriving instance GHC.Classes.Ord a_321 => GHC.Classes.Ord (FinallyClause a_321)
  
  deriving instance GHC.Show.Show a_322 => GHC.Show.Show (FinallyClause a_322)
  
  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 ForInClause a = ForInClause
    { ann :: a,
      left :: (AST.Parse.Err (Variables a)),
      right :: (GHC.Base.NonEmpty (AST.Parse.Err ((AnonymousComma GHC.Generics.:+: Expression GHC.Generics.:+: Lambda) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_323.
        AST.Traversable1.Class.Traversable1 a_323
      )
  
  instance AST.Unmarshal.SymbolMatching ForInClause where
    matchedSymbols _ = [185]
    showFailure _ node_324 =
      "expected "
        GHC.Base.<> ( "for_in_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 (ForInClause a_329)
  
  deriving instance GHC.Classes.Ord a_330 => GHC.Classes.Ord (ForInClause a_330)
  
  deriving instance GHC.Show.Show a_331 => GHC.Show.Show (ForInClause a_331)
  
  instance AST.Unmarshal.Unmarshal ForInClause
  
  instance Data.Foldable.Foldable ForInClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ForInClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ForInClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ForStatement a = ForStatement
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err (ElseClause a))),
      body :: (AST.Parse.Err (Block a)),
      left :: (AST.Parse.Err (Variables a)),
      right :: (AST.Parse.Err (ExpressionList a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_332.
        AST.Traversable1.Class.Traversable1 a_332
      )
  
  instance AST.Unmarshal.SymbolMatching ForStatement where
    matchedSymbols _ = [126]
    showFailure _ node_333 =
      "expected "
        GHC.Base.<> ( "for_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 (ForStatement a_338)
  
  deriving instance GHC.Classes.Ord a_339 => GHC.Classes.Ord (ForStatement a_339)
  
  deriving instance GHC.Show.Show a_340 => GHC.Show.Show (ForStatement a_340)
  
  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 FormatExpression a = FormatExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_341.
        AST.Traversable1.Class.Traversable1 a_341
      )
  
  instance AST.Unmarshal.SymbolMatching FormatExpression where
    matchedSymbols _ = [192]
    showFailure _ node_342 =
      "expected "
        GHC.Base.<> ( "format_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 (FormatExpression a_347)
  
  deriving instance GHC.Classes.Ord a_348 => GHC.Classes.Ord (FormatExpression a_348)
  
  deriving instance GHC.Show.Show a_349 => GHC.Show.Show (FormatExpression a_349)
  
  instance AST.Unmarshal.Unmarshal FormatExpression
  
  instance Data.Foldable.Foldable FormatExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FormatExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FormatExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data FormatSpecifier a = FormatSpecifier
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (FormatExpression a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_350.
        AST.Traversable1.Class.Traversable1 a_350
      )
  
  instance AST.Unmarshal.SymbolMatching FormatSpecifier where
    matchedSymbols _ = [191]
    showFailure _ node_351 =
      "expected "
        GHC.Base.<> ( "format_specifier"
                        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 (FormatSpecifier a_356)
  
  deriving instance GHC.Classes.Ord a_357 => GHC.Classes.Ord (FormatSpecifier a_357)
  
  deriving instance GHC.Show.Show a_358 => GHC.Show.Show (FormatSpecifier a_358)
  
  instance AST.Unmarshal.Unmarshal FormatSpecifier
  
  instance Data.Foldable.Foldable FormatSpecifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FormatSpecifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FormatSpecifier 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 (Block a)),
      name :: (AST.Parse.Err (Identifier a)),
      parameters :: (AST.Parse.Err (Parameters a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_359.
        AST.Traversable1.Class.Traversable1 a_359
      )
  
  instance AST.Unmarshal.SymbolMatching FunctionDefinition where
    matchedSymbols _ = [133]
    showFailure _ node_360 =
      "expected "
        GHC.Base.<> ( "function_definition"
                        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 (FunctionDefinition a_365)
  
  deriving instance GHC.Classes.Ord a_366 => GHC.Classes.Ord (FunctionDefinition a_366)
  
  deriving instance GHC.Show.Show a_367 => GHC.Show.Show (FunctionDefinition a_367)
  
  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 FutureImportStatement a = FutureImportStatement
    { ann :: a,
      name :: (GHC.Base.NonEmpty (AST.Parse.Err ((AliasedImport GHC.Generics.:+: DottedName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_368.
        AST.Traversable1.Class.Traversable1 a_368
      )
  
  instance AST.Unmarshal.SymbolMatching FutureImportStatement where
    matchedSymbols _ = [107]
    showFailure _ node_369 =
      "expected "
        GHC.Base.<> ( "future_import_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 (FutureImportStatement a_374)
  
  deriving instance GHC.Classes.Ord a_375 => GHC.Classes.Ord (FutureImportStatement a_375)
  
  deriving instance GHC.Show.Show a_376 => GHC.Show.Show (FutureImportStatement a_376)
  
  instance AST.Unmarshal.Unmarshal FutureImportStatement
  
  instance Data.Foldable.Foldable FutureImportStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor FutureImportStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable FutureImportStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data GeneratorExpression a = GeneratorExpression
    { ann :: a,
      body :: (AST.Parse.Err (Expression a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ForInClause GHC.Generics.:+: IfClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_377.
        AST.Traversable1.Class.Traversable1 a_377
      )
  
  instance AST.Unmarshal.SymbolMatching GeneratorExpression where
    matchedSymbols _ = [184]
    showFailure _ node_378 =
      "expected "
        GHC.Base.<> ( "generator_expression"
                        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 (GeneratorExpression a_383)
  
  deriving instance GHC.Classes.Ord a_384 => GHC.Classes.Ord (GeneratorExpression a_384)
  
  deriving instance GHC.Show.Show a_385 => GHC.Show.Show (GeneratorExpression a_385)
  
  instance AST.Unmarshal.Unmarshal GeneratorExpression
  
  instance Data.Foldable.Foldable GeneratorExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GeneratorExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GeneratorExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data GlobalStatement a = GlobalStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_386.
        AST.Traversable1.Class.Traversable1 a_386
      )
  
  instance AST.Unmarshal.SymbolMatching GlobalStatement where
    matchedSymbols _ = [141]
    showFailure _ node_387 =
      "expected "
        GHC.Base.<> ( "global_statement"
                        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 (GlobalStatement a_392)
  
  deriving instance GHC.Classes.Ord a_393 => GHC.Classes.Ord (GlobalStatement a_393)
  
  deriving instance GHC.Show.Show a_394 => GHC.Show.Show (GlobalStatement a_394)
  
  instance AST.Unmarshal.Unmarshal GlobalStatement
  
  instance Data.Foldable.Foldable GlobalStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GlobalStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GlobalStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfClause a = IfClause
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_395.
        AST.Traversable1.Class.Traversable1 a_395
      )
  
  instance AST.Unmarshal.SymbolMatching IfClause where
    matchedSymbols _ = [186]
    showFailure _ node_396 =
      "expected "
        GHC.Base.<> ( "if_clause"
                        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 (IfClause a_401)
  
  deriving instance GHC.Classes.Ord a_402 => GHC.Classes.Ord (IfClause a_402)
  
  deriving instance GHC.Show.Show a_403 => GHC.Show.Show (IfClause a_403)
  
  instance AST.Unmarshal.Unmarshal IfClause
  
  instance Data.Foldable.Foldable IfClause where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IfClause where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IfClause where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfStatement a = IfStatement
    { ann :: a,
      alternative :: ([AST.Parse.Err ((ElifClause GHC.Generics.:+: ElseClause) a)]),
      consequence :: (AST.Parse.Err (Block a)),
      condition :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_404.
        AST.Traversable1.Class.Traversable1 a_404
      )
  
  instance AST.Unmarshal.SymbolMatching IfStatement where
    matchedSymbols _ = [123]
    showFailure _ node_405 =
      "expected "
        GHC.Base.<> ( "if_statement"
                        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 (IfStatement a_410)
  
  deriving instance GHC.Classes.Ord a_411 => GHC.Classes.Ord (IfStatement a_411)
  
  deriving instance GHC.Show.Show a_412 => GHC.Show.Show (IfStatement a_412)
  
  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 ImportFromStatement a = ImportFromStatement
    { ann :: a,
      name :: ([AST.Parse.Err ((AliasedImport GHC.Generics.:+: DottedName) a)]),
      moduleName :: (AST.Parse.Err ((DottedName GHC.Generics.:+: RelativeImport) a)),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (WildcardImport a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_413.
        AST.Traversable1.Class.Traversable1 a_413
      )
  
  instance AST.Unmarshal.SymbolMatching ImportFromStatement where
    matchedSymbols _ = [108]
    showFailure _ node_414 =
      "expected "
        GHC.Base.<> ( "import_from_statement"
                        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 (ImportFromStatement a_419)
  
  deriving instance GHC.Classes.Ord a_420 => GHC.Classes.Ord (ImportFromStatement a_420)
  
  deriving instance GHC.Show.Show a_421 => GHC.Show.Show (ImportFromStatement a_421)
  
  instance AST.Unmarshal.Unmarshal ImportFromStatement
  
  instance Data.Foldable.Foldable ImportFromStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ImportFromStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ImportFromStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ImportPrefix a = ImportPrefix {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_422.
        AST.Traversable1.Class.Traversable1 a_422
      )
  
  instance AST.Unmarshal.SymbolMatching ImportPrefix where
    matchedSymbols _ = [105]
    showFailure _ node_423 =
      "expected "
        GHC.Base.<> ( "import_prefix"
                        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 (ImportPrefix a_428)
  
  deriving instance GHC.Classes.Ord a_429 => GHC.Classes.Ord (ImportPrefix a_429)
  
  deriving instance GHC.Show.Show a_430 => GHC.Show.Show (ImportPrefix a_430)
  
  instance AST.Unmarshal.Unmarshal ImportPrefix
  
  instance Data.Foldable.Foldable ImportPrefix where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ImportPrefix where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ImportPrefix where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ImportStatement a = ImportStatement
    { ann :: a,
      name :: (GHC.Base.NonEmpty (AST.Parse.Err ((AliasedImport GHC.Generics.:+: DottedName) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_431.
        AST.Traversable1.Class.Traversable1 a_431
      )
  
  instance AST.Unmarshal.SymbolMatching ImportStatement where
    matchedSymbols _ = [104]
    showFailure _ node_432 =
      "expected "
        GHC.Base.<> ( "import_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 (ImportStatement a_437)
  
  deriving instance GHC.Classes.Ord a_438 => GHC.Classes.Ord (ImportStatement a_438)
  
  deriving instance GHC.Show.Show a_439 => GHC.Show.Show (ImportStatement a_439)
  
  instance AST.Unmarshal.Unmarshal ImportStatement
  
  instance Data.Foldable.Foldable ImportStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ImportStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ImportStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Interpolation a = Interpolation
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: FormatSpecifier GHC.Generics.:+: TypeConversion) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_440.
        AST.Traversable1.Class.Traversable1 a_440
      )
  
  instance AST.Unmarshal.SymbolMatching Interpolation where
    matchedSymbols _ = [190]
    showFailure _ node_441 =
      "expected "
        GHC.Base.<> ( "interpolation"
                        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 (Interpolation a_446)
  
  deriving instance GHC.Classes.Ord a_447 => GHC.Classes.Ord (Interpolation a_447)
  
  deriving instance GHC.Show.Show a_448 => GHC.Show.Show (Interpolation a_448)
  
  instance AST.Unmarshal.Unmarshal Interpolation
  
  instance Data.Foldable.Foldable Interpolation where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Interpolation where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Interpolation where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data KeywordArgument a = KeywordArgument
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_449.
        AST.Traversable1.Class.Traversable1 a_449
      )
  
  instance AST.Unmarshal.SymbolMatching KeywordArgument where
    matchedSymbols _ = [173]
    showFailure _ node_450 =
      "expected "
        GHC.Base.<> ( "keyword_argument"
                        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 (KeywordArgument a_455)
  
  deriving instance GHC.Classes.Ord a_456 => GHC.Classes.Ord (KeywordArgument a_456)
  
  deriving instance GHC.Show.Show a_457 => GHC.Show.Show (KeywordArgument a_457)
  
  instance AST.Unmarshal.Unmarshal KeywordArgument
  
  instance Data.Foldable.Foldable KeywordArgument where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor KeywordArgument where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable KeywordArgument where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Lambda a = Lambda
    { ann :: a,
      body :: (AST.Parse.Err ((Expression GHC.Generics.:+: Lambda) a)),
      parameters :: (GHC.Maybe.Maybe (AST.Parse.Err (LambdaParameters a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_458.
        AST.Traversable1.Class.Traversable1 a_458
      )
  
  instance AST.Unmarshal.SymbolMatching Lambda where
    matchedSymbols _ = [161, 162]
    showFailure _ node_459 =
      "expected "
        GHC.Base.<> ( "lambda, lambda"
                        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 (Lambda a_464)
  
  deriving instance GHC.Classes.Ord a_465 => GHC.Classes.Ord (Lambda a_465)
  
  deriving instance GHC.Show.Show a_466 => GHC.Show.Show (Lambda a_466)
  
  instance AST.Unmarshal.Unmarshal Lambda
  
  instance Data.Foldable.Foldable Lambda where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Lambda where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Lambda where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data LambdaParameters a = LambdaParameters
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Parameter a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_467.
        AST.Traversable1.Class.Traversable1 a_467
      )
  
  instance AST.Unmarshal.SymbolMatching LambdaParameters where
    matchedSymbols _ = [135]
    showFailure _ node_468 =
      "expected "
        GHC.Base.<> ( "lambda_parameters"
                        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 (LambdaParameters a_473)
  
  deriving instance GHC.Classes.Ord a_474 => GHC.Classes.Ord (LambdaParameters a_474)
  
  deriving instance GHC.Show.Show a_475 => GHC.Show.Show (LambdaParameters a_475)
  
  instance AST.Unmarshal.Unmarshal LambdaParameters
  
  instance Data.Foldable.Foldable LambdaParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LambdaParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LambdaParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data List a = List
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: ListSplat) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_476.
        AST.Traversable1.Class.Traversable1 a_476
      )
  
  instance AST.Unmarshal.SymbolMatching List where
    matchedSymbols _ = [174]
    showFailure _ node_477 =
      "expected "
        GHC.Base.<> ( "list"
                        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 (List a_482)
  
  deriving instance GHC.Classes.Ord a_483 => GHC.Classes.Ord (List a_483)
  
  deriving instance GHC.Show.Show a_484 => GHC.Show.Show (List a_484)
  
  instance AST.Unmarshal.Unmarshal List
  
  instance Data.Foldable.Foldable List where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor List where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable List where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ListComprehension a = ListComprehension
    { ann :: a,
      body :: (AST.Parse.Err (Expression a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ForInClause GHC.Generics.:+: IfClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_485.
        AST.Traversable1.Class.Traversable1 a_485
      )
  
  instance AST.Unmarshal.SymbolMatching ListComprehension where
    matchedSymbols _ = [176]
    showFailure _ node_486 =
      "expected "
        GHC.Base.<> ( "list_comprehension"
                        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 (ListComprehension a_491)
  
  deriving instance GHC.Classes.Ord a_492 => GHC.Classes.Ord (ListComprehension a_492)
  
  deriving instance GHC.Show.Show a_493 => GHC.Show.Show (ListComprehension a_493)
  
  instance AST.Unmarshal.Unmarshal ListComprehension
  
  instance Data.Foldable.Foldable ListComprehension where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ListComprehension where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ListComprehension where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ListSplat a = ListSplat
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_494.
        AST.Traversable1.Class.Traversable1 a_494
      )
  
  instance AST.Unmarshal.SymbolMatching ListSplat where
    matchedSymbols _ = [139]
    showFailure _ node_495 =
      "expected "
        GHC.Base.<> ( "list_splat"
                        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 (ListSplat a_500)
  
  deriving instance GHC.Classes.Ord a_501 => GHC.Classes.Ord (ListSplat a_501)
  
  deriving instance GHC.Show.Show a_502 => GHC.Show.Show (ListSplat a_502)
  
  instance AST.Unmarshal.Unmarshal ListSplat
  
  instance Data.Foldable.Foldable ListSplat where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ListSplat where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ListSplat where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Module a = Module
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((CompoundStatement GHC.Generics.:+: SimpleStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_503.
        AST.Traversable1.Class.Traversable1 a_503
      )
  
  instance AST.Unmarshal.SymbolMatching Module where
    matchedSymbols _ = [101]
    showFailure _ node_504 =
      "expected "
        GHC.Base.<> ( "module"
                        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 (Module a_509)
  
  deriving instance GHC.Classes.Ord a_510 => GHC.Classes.Ord (Module a_510)
  
  deriving instance GHC.Show.Show a_511 => GHC.Show.Show (Module a_511)
  
  instance AST.Unmarshal.Unmarshal Module
  
  instance Data.Foldable.Foldable Module where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Module where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Module where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NamedExpression a = NamedExpression
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_512.
        AST.Traversable1.Class.Traversable1 a_512
      )
  
  instance AST.Unmarshal.SymbolMatching NamedExpression where
    matchedSymbols _ = [116]
    showFailure _ node_513 =
      "expected "
        GHC.Base.<> ( "named_expression"
                        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 (NamedExpression a_518)
  
  deriving instance GHC.Classes.Ord a_519 => GHC.Classes.Ord (NamedExpression a_519)
  
  deriving instance GHC.Show.Show a_520 => GHC.Show.Show (NamedExpression a_520)
  
  instance AST.Unmarshal.Unmarshal NamedExpression
  
  instance Data.Foldable.Foldable NamedExpression where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NamedExpression where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NamedExpression where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NonlocalStatement a = NonlocalStatement
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_521.
        AST.Traversable1.Class.Traversable1 a_521
      )
  
  instance AST.Unmarshal.SymbolMatching NonlocalStatement where
    matchedSymbols _ = [142]
    showFailure _ node_522 =
      "expected "
        GHC.Base.<> ( "nonlocal_statement"
                        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 (NonlocalStatement a_527)
  
  deriving instance GHC.Classes.Ord a_528 => GHC.Classes.Ord (NonlocalStatement a_528)
  
  deriving instance GHC.Show.Show a_529 => GHC.Show.Show (NonlocalStatement a_529)
  
  instance AST.Unmarshal.Unmarshal NonlocalStatement
  
  instance Data.Foldable.Foldable NonlocalStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NonlocalStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NonlocalStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data NotOperator a = NotOperator
    { ann :: a,
      argument :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_530.
        AST.Traversable1.Class.Traversable1 a_530
      )
  
  instance AST.Unmarshal.SymbolMatching NotOperator where
    matchedSymbols _ = [156]
    showFailure _ node_531 =
      "expected "
        GHC.Base.<> ( "not_operator"
                        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 (NotOperator a_536)
  
  deriving instance GHC.Classes.Ord a_537 => GHC.Classes.Ord (NotOperator a_537)
  
  deriving instance GHC.Show.Show a_538 => GHC.Show.Show (NotOperator a_538)
  
  instance AST.Unmarshal.Unmarshal NotOperator
  
  instance Data.Foldable.Foldable NotOperator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor NotOperator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable NotOperator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Pair a = Pair
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      key :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_539.
        AST.Traversable1.Class.Traversable1 a_539
      )
  
  instance AST.Unmarshal.SymbolMatching Pair where
    matchedSymbols _ = [179]
    showFailure _ node_540 =
      "expected "
        GHC.Base.<> ( "pair"
                        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 (Pair a_545)
  
  deriving instance GHC.Classes.Ord a_546 => GHC.Classes.Ord (Pair a_546)
  
  deriving instance GHC.Show.Show a_547 => GHC.Show.Show (Pair a_547)
  
  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 Parameters a = Parameters
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Parameter a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_548.
        AST.Traversable1.Class.Traversable1 a_548
      )
  
  instance AST.Unmarshal.SymbolMatching Parameters where
    matchedSymbols _ = [134]
    showFailure _ node_549 =
      "expected "
        GHC.Base.<> ( "parameters"
                        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 (Parameters a_554)
  
  deriving instance GHC.Classes.Ord a_555 => GHC.Classes.Ord (Parameters a_555)
  
  deriving instance GHC.Show.Show a_556 => GHC.Show.Show (Parameters a_556)
  
  instance AST.Unmarshal.Unmarshal Parameters
  
  instance Data.Foldable.Foldable Parameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Parameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Parameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ParenthesizedExpression a = ParenthesizedExpression
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: ListSplat GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_557.
        AST.Traversable1.Class.Traversable1 a_557
      )
  
  instance AST.Unmarshal.SymbolMatching ParenthesizedExpression where
    matchedSymbols _ = [145, 182]
    showFailure _ node_558 =
      "expected "
        GHC.Base.<> ( "parenthesized_expression, parenthesized_expression"
                        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 (ParenthesizedExpression a_563)
  
  deriving instance GHC.Classes.Ord a_564 => GHC.Classes.Ord (ParenthesizedExpression a_564)
  
  deriving instance GHC.Show.Show a_565 => GHC.Show.Show (ParenthesizedExpression a_565)
  
  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 PassStatement a = PassStatement {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_566.
        AST.Traversable1.Class.Traversable1 a_566
      )
  
  instance AST.Unmarshal.SymbolMatching PassStatement where
    matchedSymbols _ = [120]
    showFailure _ node_567 =
      "expected "
        GHC.Base.<> ( "pass_statement"
                        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 (PassStatement a_572)
  
  deriving instance GHC.Classes.Ord a_573 => GHC.Classes.Ord (PassStatement a_573)
  
  deriving instance GHC.Show.Show a_574 => GHC.Show.Show (PassStatement a_574)
  
  instance AST.Unmarshal.Unmarshal PassStatement
  
  instance Data.Foldable.Foldable PassStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PassStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PassStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data PrintStatement a = PrintStatement
    { ann :: a,
      argument :: ([AST.Parse.Err (Expression a)]),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Chevron a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_575.
        AST.Traversable1.Class.Traversable1 a_575
      )
  
  instance AST.Unmarshal.SymbolMatching PrintStatement where
    matchedSymbols _ = [112]
    showFailure _ node_576 =
      "expected "
        GHC.Base.<> ( "print_statement"
                        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 (PrintStatement a_581)
  
  deriving instance GHC.Classes.Ord a_582 => GHC.Classes.Ord (PrintStatement a_582)
  
  deriving instance GHC.Show.Show a_583 => GHC.Show.Show (PrintStatement a_583)
  
  instance AST.Unmarshal.Unmarshal PrintStatement
  
  instance Data.Foldable.Foldable PrintStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor PrintStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable PrintStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RaiseStatement a = RaiseStatement
    { ann :: a,
      cause :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ExpressionList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_584.
        AST.Traversable1.Class.Traversable1 a_584
      )
  
  instance AST.Unmarshal.SymbolMatching RaiseStatement where
    matchedSymbols _ = [119]
    showFailure _ node_585 =
      "expected "
        GHC.Base.<> ( "raise_statement"
                        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 (RaiseStatement a_590)
  
  deriving instance GHC.Classes.Ord a_591 => GHC.Classes.Ord (RaiseStatement a_591)
  
  deriving instance GHC.Show.Show a_592 => GHC.Show.Show (RaiseStatement a_592)
  
  instance AST.Unmarshal.Unmarshal RaiseStatement
  
  instance Data.Foldable.Foldable RaiseStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RaiseStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RaiseStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RelativeImport a = RelativeImport
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((DottedName GHC.Generics.:+: ImportPrefix) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_593.
        AST.Traversable1.Class.Traversable1 a_593
      )
  
  instance AST.Unmarshal.SymbolMatching RelativeImport where
    matchedSymbols _ = [106]
    showFailure _ node_594 =
      "expected "
        GHC.Base.<> ( "relative_import"
                        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 (RelativeImport a_599)
  
  deriving instance GHC.Classes.Ord a_600 => GHC.Classes.Ord (RelativeImport a_600)
  
  deriving instance GHC.Show.Show a_601 => GHC.Show.Show (RelativeImport a_601)
  
  instance AST.Unmarshal.Unmarshal RelativeImport
  
  instance Data.Foldable.Foldable RelativeImport where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RelativeImport where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RelativeImport where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ReturnStatement a = ReturnStatement
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ExpressionList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_602.
        AST.Traversable1.Class.Traversable1 a_602
      )
  
  instance AST.Unmarshal.SymbolMatching ReturnStatement where
    matchedSymbols _ = [117]
    showFailure _ node_603 =
      "expected "
        GHC.Base.<> ( "return_statement"
                        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 (ReturnStatement a_608)
  
  deriving instance GHC.Classes.Ord a_609 => GHC.Classes.Ord (ReturnStatement a_609)
  
  deriving instance GHC.Show.Show a_610 => GHC.Show.Show (ReturnStatement a_610)
  
  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 Set a = Set
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: ListSplat) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_611.
        AST.Traversable1.Class.Traversable1 a_611
      )
  
  instance AST.Unmarshal.SymbolMatching Set where
    matchedSymbols _ = [180]
    showFailure _ node_612 =
      "expected "
        GHC.Base.<> ( "set"
                        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 (Set a_617)
  
  deriving instance GHC.Classes.Ord a_618 => GHC.Classes.Ord (Set a_618)
  
  deriving instance GHC.Show.Show a_619 => GHC.Show.Show (Set a_619)
  
  instance AST.Unmarshal.Unmarshal Set
  
  instance Data.Foldable.Foldable Set where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Set where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Set where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SetComprehension a = SetComprehension
    { ann :: a,
      body :: (AST.Parse.Err (Expression a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ForInClause GHC.Generics.:+: IfClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_620.
        AST.Traversable1.Class.Traversable1 a_620
      )
  
  instance AST.Unmarshal.SymbolMatching SetComprehension where
    matchedSymbols _ = [181]
    showFailure _ node_621 =
      "expected "
        GHC.Base.<> ( "set_comprehension"
                        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 (SetComprehension a_626)
  
  deriving instance GHC.Classes.Ord a_627 => GHC.Classes.Ord (SetComprehension a_627)
  
  deriving instance GHC.Show.Show a_628 => GHC.Show.Show (SetComprehension a_628)
  
  instance AST.Unmarshal.Unmarshal SetComprehension
  
  instance Data.Foldable.Foldable SetComprehension where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SetComprehension where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SetComprehension where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Slice a = Slice
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (Expression a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_629.
        AST.Traversable1.Class.Traversable1 a_629
      )
  
  instance AST.Unmarshal.SymbolMatching Slice where
    matchedSymbols _ = [169]
    showFailure _ node_630 =
      "expected "
        GHC.Base.<> ( "slice"
                        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 (Slice a_635)
  
  deriving instance GHC.Classes.Ord a_636 => GHC.Classes.Ord (Slice a_636)
  
  deriving instance GHC.Show.Show a_637 => GHC.Show.Show (Slice a_637)
  
  instance AST.Unmarshal.Unmarshal Slice
  
  instance Data.Foldable.Foldable Slice where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Slice where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Slice where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data String a = String
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_638.
        AST.Traversable1.Class.Traversable1 a_638
      )
  
  instance AST.Unmarshal.SymbolMatching String where
    matchedSymbols _ = [189]
    showFailure _ node_639 =
      "expected "
        GHC.Base.<> ( "string"
                        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 (String a_644)
  
  deriving instance GHC.Classes.Ord a_645 => GHC.Classes.Ord (String a_645)
  
  deriving instance GHC.Show.Show a_646 => GHC.Show.Show (String a_646)
  
  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
  
  data Subscript a = Subscript
    { ann :: a,
      subscript :: (GHC.Base.NonEmpty (AST.Parse.Err ((AnonymousComma GHC.Generics.:+: Expression GHC.Generics.:+: Slice) a))),
      value :: (AST.Parse.Err (PrimaryExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_647.
        AST.Traversable1.Class.Traversable1 a_647
      )
  
  instance AST.Unmarshal.SymbolMatching Subscript where
    matchedSymbols _ = [168]
    showFailure _ node_648 =
      "expected "
        GHC.Base.<> ( "subscript"
                        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 (Subscript a_653)
  
  deriving instance GHC.Classes.Ord a_654 => GHC.Classes.Ord (Subscript a_654)
  
  deriving instance GHC.Show.Show a_655 => GHC.Show.Show (Subscript a_655)
  
  instance AST.Unmarshal.Unmarshal Subscript
  
  instance Data.Foldable.Foldable Subscript where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Subscript where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Subscript where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TryStatement a = TryStatement
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ElseClause GHC.Generics.:+: ExceptClause GHC.Generics.:+: FinallyClause) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_656.
        AST.Traversable1.Class.Traversable1 a_656
      )
  
  instance AST.Unmarshal.SymbolMatching TryStatement where
    matchedSymbols _ = [128]
    showFailure _ node_657 =
      "expected "
        GHC.Base.<> ( "try_statement"
                        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 (TryStatement a_662)
  
  deriving instance GHC.Classes.Ord a_663 => GHC.Classes.Ord (TryStatement a_663)
  
  deriving instance GHC.Show.Show a_664 => GHC.Show.Show (TryStatement a_664)
  
  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 Tuple a = Tuple
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: Yield) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_665.
        AST.Traversable1.Class.Traversable1 a_665
      )
  
  instance AST.Unmarshal.SymbolMatching Tuple where
    matchedSymbols _ = [183]
    showFailure _ node_666 =
      "expected "
        GHC.Base.<> ( "tuple"
                        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 (Tuple a_671)
  
  deriving instance GHC.Classes.Ord a_672 => GHC.Classes.Ord (Tuple a_672)
  
  deriving instance GHC.Show.Show a_673 => GHC.Show.Show (Tuple a_673)
  
  instance AST.Unmarshal.Unmarshal Tuple
  
  instance Data.Foldable.Foldable Tuple where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Tuple where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Tuple where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Type a = Type {ann :: a, extraChildren :: (AST.Parse.Err (Expression a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_674.
        AST.Traversable1.Class.Traversable1 a_674
      )
  
  instance AST.Unmarshal.SymbolMatching Type where
    matchedSymbols _ = [172]
    showFailure _ node_675 =
      "expected "
        GHC.Base.<> ( "type"
                        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 (Type a_680)
  
  deriving instance GHC.Classes.Ord a_681 => GHC.Classes.Ord (Type a_681)
  
  deriving instance GHC.Show.Show a_682 => GHC.Show.Show (Type a_682)
  
  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 TypedDefaultParameter a = TypedDefaultParameter
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      name :: (AST.Parse.Err (Identifier a)),
      type' :: (AST.Parse.Err (Type a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_683.
        AST.Traversable1.Class.Traversable1 a_683
      )
  
  instance AST.Unmarshal.SymbolMatching TypedDefaultParameter where
    matchedSymbols _ = [138]
    showFailure _ node_684 =
      "expected "
        GHC.Base.<> ( "typed_default_parameter"
                        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 (TypedDefaultParameter a_689)
  
  deriving instance GHC.Classes.Ord a_690 => GHC.Classes.Ord (TypedDefaultParameter a_690)
  
  deriving instance GHC.Show.Show a_691 => GHC.Show.Show (TypedDefaultParameter a_691)
  
  instance AST.Unmarshal.Unmarshal TypedDefaultParameter
  
  instance Data.Foldable.Foldable TypedDefaultParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypedDefaultParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypedDefaultParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data TypedParameter a = TypedParameter
    { ann :: a,
      type' :: (AST.Parse.Err (Type a)),
      extraChildren :: (AST.Parse.Err ((DictionarySplat GHC.Generics.:+: Identifier GHC.Generics.:+: ListSplat) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_692.
        AST.Traversable1.Class.Traversable1 a_692
      )
  
  instance AST.Unmarshal.SymbolMatching TypedParameter where
    matchedSymbols _ = [171]
    showFailure _ node_693 =
      "expected "
        GHC.Base.<> ( "typed_parameter"
                        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 (TypedParameter a_698)
  
  deriving instance GHC.Classes.Ord a_699 => GHC.Classes.Ord (TypedParameter a_699)
  
  deriving instance GHC.Show.Show a_700 => GHC.Show.Show (TypedParameter a_700)
  
  instance AST.Unmarshal.Unmarshal TypedParameter
  
  instance Data.Foldable.Foldable TypedParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypedParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypedParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnaryOperator a = UnaryOperator
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousTilde) a)),
      argument :: (AST.Parse.Err (PrimaryExpression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_701.
        AST.Traversable1.Class.Traversable1 a_701
      )
  
  instance AST.Unmarshal.SymbolMatching UnaryOperator where
    matchedSymbols _ = [159]
    showFailure _ node_702 =
      "expected "
        GHC.Base.<> ( "unary_operator"
                        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 (UnaryOperator a_707)
  
  deriving instance GHC.Classes.Ord a_708 => GHC.Classes.Ord (UnaryOperator a_708)
  
  deriving instance GHC.Show.Show a_709 => GHC.Show.Show (UnaryOperator a_709)
  
  instance AST.Unmarshal.Unmarshal UnaryOperator
  
  instance Data.Foldable.Foldable UnaryOperator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnaryOperator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnaryOperator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Variables a = Variables
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (PrimaryExpression a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_710.
        AST.Traversable1.Class.Traversable1 a_710
      )
  
  instance AST.Unmarshal.SymbolMatching Variables where
    matchedSymbols _ = [150]
    showFailure _ node_711 =
      "expected "
        GHC.Base.<> ( "variables"
                        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 (Variables a_716)
  
  deriving instance GHC.Classes.Ord a_717 => GHC.Classes.Ord (Variables a_717)
  
  deriving instance GHC.Show.Show a_718 => GHC.Show.Show (Variables a_718)
  
  instance AST.Unmarshal.Unmarshal Variables
  
  instance Data.Foldable.Foldable Variables where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Variables where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Variables where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WhileStatement a = WhileStatement
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err (ElseClause a))),
      body :: (AST.Parse.Err (Block a)),
      condition :: (AST.Parse.Err (Expression a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_719.
        AST.Traversable1.Class.Traversable1 a_719
      )
  
  instance AST.Unmarshal.SymbolMatching WhileStatement where
    matchedSymbols _ = [127]
    showFailure _ node_720 =
      "expected "
        GHC.Base.<> ( "while_statement"
                        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 (WhileStatement a_725)
  
  deriving instance GHC.Classes.Ord a_726 => GHC.Classes.Ord (WhileStatement a_726)
  
  deriving instance GHC.Show.Show a_727 => GHC.Show.Show (WhileStatement a_727)
  
  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 WildcardImport a = WildcardImport {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_728.
        AST.Traversable1.Class.Traversable1 a_728
      )
  
  instance AST.Unmarshal.SymbolMatching WildcardImport where
    matchedSymbols _ = [111]
    showFailure _ node_729 =
      "expected "
        GHC.Base.<> ( "wildcard_import"
                        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 (WildcardImport a_734)
  
  deriving instance GHC.Classes.Ord a_735 => GHC.Classes.Ord (WildcardImport a_735)
  
  deriving instance GHC.Show.Show a_736 => GHC.Show.Show (WildcardImport a_736)
  
  instance AST.Unmarshal.Unmarshal WildcardImport
  
  instance Data.Foldable.Foldable WildcardImport where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor WildcardImport where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable WildcardImport where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WithItem a = WithItem
    { ann :: a,
      value :: (AST.Parse.Err (Expression a)),
      alias :: (GHC.Maybe.Maybe (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 WithItem where
    matchedSymbols _ = [132]
    showFailure _ node_738 =
      "expected "
        GHC.Base.<> ( "with_item"
                        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 (WithItem a_743)
  
  deriving instance GHC.Classes.Ord a_744 => GHC.Classes.Ord (WithItem a_744)
  
  deriving instance GHC.Show.Show a_745 => GHC.Show.Show (WithItem a_745)
  
  instance AST.Unmarshal.Unmarshal WithItem
  
  instance Data.Foldable.Foldable WithItem where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor WithItem where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable WithItem where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WithStatement a = WithStatement
    { ann :: a,
      body :: (AST.Parse.Err (Block a)),
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (WithItem a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_746.
        AST.Traversable1.Class.Traversable1 a_746
      )
  
  instance AST.Unmarshal.SymbolMatching WithStatement where
    matchedSymbols _ = [131]
    showFailure _ node_747 =
      "expected "
        GHC.Base.<> ( "with_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 (WithStatement a_752)
  
  deriving instance GHC.Classes.Ord a_753 => GHC.Classes.Ord (WithStatement a_753)
  
  deriving instance GHC.Show.Show a_754 => GHC.Show.Show (WithStatement a_754)
  
  instance AST.Unmarshal.Unmarshal WithStatement
  
  instance Data.Foldable.Foldable WithStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor WithStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable WithStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Yield a = Yield
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: ExpressionList) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_755.
        AST.Traversable1.Class.Traversable1 a_755
      )
  
  instance AST.Unmarshal.SymbolMatching Yield where
    matchedSymbols _ = [166]
    showFailure _ node_756 =
      "expected "
        GHC.Base.<> ( "yield"
                        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 (Yield a_761)
  
  deriving instance GHC.Classes.Ord a_762 => GHC.Classes.Ord (Yield a_762)
  
  deriving instance GHC.Show.Show a_763 => GHC.Show.Show (Yield a_763)
  
  instance AST.Unmarshal.Unmarshal Yield
  
  instance Data.Foldable.Foldable Yield where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Yield where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Yield where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousBangEqual = AST.Token.Token "!=" 58
  
  type AnonymousPercent = AST.Token.Token "%" 48
  
  type AnonymousPercentEqual = AST.Token.Token "%=" 70
  
  type AnonymousAmpersand = AST.Token.Token "&" 51
  
  type AnonymousAmpersandEqual = AST.Token.Token "&=" 74
  
  type AnonymousLParen = AST.Token.Token "(" 6
  
  type AnonymousRParen = AST.Token.Token ")" 7
  
  type AnonymousStar = AST.Token.Token "*" 10
  
  type AnonymousStarStar = AST.Token.Token "**" 36
  
  type AnonymousStarStarEqual = AST.Token.Token "**=" 71
  
  type AnonymousStarEqual = AST.Token.Token "*=" 66
  
  type AnonymousPlus = AST.Token.Token "+" 45
  
  type AnonymousPlusEqual = AST.Token.Token "+=" 64
  
  type AnonymousComma = AST.Token.Token "," 8
  
  type AnonymousMinus = AST.Token.Token "-" 46
  
  type AnonymousMinusEqual = AST.Token.Token "-=" 65
  
  type AnonymousMinusRAngle = AST.Token.Token "->" 34
  
  type AnonymousDot = AST.Token.Token "." 3
  
  type AnonymousSlash = AST.Token.Token "/" 47
  
  type AnonymousSlashSlash = AST.Token.Token "//" 49
  
  type AnonymousSlashSlashEqual = AST.Token.Token "//=" 69
  
  type AnonymousSlashEqual = AST.Token.Token "/=" 67
  
  type AnonymousColon = AST.Token.Token ":" 22
  
  type AnonymousColonEqual = AST.Token.Token ":=" 14
  
  type AnonymousLAngle = AST.Token.Token "<" 55
  
  type AnonymousLAngleLAngle = AST.Token.Token "<<" 53
  
  type AnonymousLAngleLAngleEqual = AST.Token.Token "<<=" 73
  
  type AnonymousLAngleEqual = AST.Token.Token "<=" 56
  
  type AnonymousLAngleRAngle = AST.Token.Token "<>" 61
  
  type AnonymousEqual = AST.Token.Token "=" 35
  
  type AnonymousEqualEqual = AST.Token.Token "==" 57
  
  type AnonymousRAngle = AST.Token.Token ">" 60
  
  type AnonymousRAngleEqual = AST.Token.Token ">=" 59
  
  type AnonymousRAngleRAngle = AST.Token.Token ">>" 12
  
  type AnonymousRAngleRAngleEqual = AST.Token.Token ">>=" 72
  
  type AnonymousAt = AST.Token.Token "@" 41
  
  type AnonymousAtEqual = AST.Token.Token "@=" 68
  
  type AnonymousLBracket = AST.Token.Token "[" 78
  
  type AnonymousRBracket = AST.Token.Token "]" 79
  
  type AnonymousCaret = AST.Token.Token "^" 52
  
  type AnonymousCaretEqual = AST.Token.Token "^=" 75
  
  type AnonymousUnderscorefutureUnderscore =
    AST.Token.Token
      "__future__"
      5
  
  type AnonymousAnd = AST.Token.Token "and" 43
  
  type AnonymousAs = AST.Token.Token "as" 9
  
  type AnonymousAssert = AST.Token.Token "assert" 13
  
  type AnonymousAsync = AST.Token.Token "async" 25
  
  type AnonymousAwait = AST.Token.Token "await" 92
  
  type AnonymousBreak = AST.Token.Token "break" 19
  
  type AnonymousClass = AST.Token.Token "class" 40
  
  type AnonymousContinue = AST.Token.Token "continue" 20
  
  type AnonymousDef = AST.Token.Token "def" 33
  
  type AnonymousDel = AST.Token.Token "del" 16
  
  type AnonymousElif = AST.Token.Token "elif" 23
  
  data Ellipsis a = Ellipsis {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_764.
        AST.Traversable1.Class.Traversable1 a_764
      )
  
  instance AST.Unmarshal.SymbolMatching Ellipsis where
    matchedSymbols _ = [80]
    showFailure _ node_765 =
      "expected "
        GHC.Base.<> ( "ellipsis"
                        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 (Ellipsis a_770)
  
  deriving instance GHC.Classes.Ord a_771 => GHC.Classes.Ord (Ellipsis a_771)
  
  deriving instance GHC.Show.Show a_772 => GHC.Show.Show (Ellipsis a_772)
  
  instance AST.Unmarshal.Unmarshal Ellipsis
  
  instance Data.Foldable.Foldable Ellipsis where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Ellipsis where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Ellipsis where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousElse = AST.Token.Token "else" 24
  
  data EscapeSequence a = EscapeSequence {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_773.
        AST.Traversable1.Class.Traversable1 a_773
      )
  
  instance AST.Unmarshal.SymbolMatching EscapeSequence where
    matchedSymbols _ = [83]
    showFailure _ node_774 =
      "expected "
        GHC.Base.<> ( "escape_sequence"
                        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 (EscapeSequence a_779)
  
  deriving instance GHC.Classes.Ord a_780 => GHC.Classes.Ord (EscapeSequence a_780)
  
  deriving instance GHC.Show.Show a_781 => GHC.Show.Show (EscapeSequence a_781)
  
  instance AST.Unmarshal.Unmarshal EscapeSequence
  
  instance Data.Foldable.Foldable EscapeSequence where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EscapeSequence where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EscapeSequence where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousExcept = AST.Token.Token "except" 30
  
  type AnonymousExec = AST.Token.Token "exec" 39
  
  data False a = False {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_782.
        AST.Traversable1.Class.Traversable1 a_782
      )
  
  instance AST.Unmarshal.SymbolMatching False where
    matchedSymbols _ = [90]
    showFailure _ node_783 =
      "expected "
        GHC.Base.<> ( "false"
                        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 (False a_788)
  
  deriving instance GHC.Classes.Ord a_789 => GHC.Classes.Ord (False a_789)
  
  deriving instance GHC.Show.Show a_790 => GHC.Show.Show (False a_790)
  
  instance AST.Unmarshal.Unmarshal False
  
  instance Data.Foldable.Foldable False where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor False where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable False where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousFinally = AST.Token.Token "finally" 31
  
  data Float a = Float {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 Float where
    matchedSymbols _ = [88]
    showFailure _ node_792 =
      "expected "
        GHC.Base.<> ( "float"
                        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 (Float a_797)
  
  deriving instance GHC.Classes.Ord a_798 => GHC.Classes.Ord (Float a_798)
  
  deriving instance GHC.Show.Show a_799 => GHC.Show.Show (Float a_799)
  
  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" 26
  
  type AnonymousFrom = AST.Token.Token "from" 4
  
  type AnonymousGlobal = AST.Token.Token "global" 37
  
  data Identifier a = Identifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_800.
        AST.Traversable1.Class.Traversable1 a_800
      )
  
  instance AST.Unmarshal.SymbolMatching Identifier where
    matchedSymbols _ = [1]
    showFailure _ node_801 =
      "expected "
        GHC.Base.<> ( "identifier"
                        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 (Identifier a_806)
  
  deriving instance GHC.Classes.Ord a_807 => GHC.Classes.Ord (Identifier a_807)
  
  deriving instance GHC.Show.Show a_808 => GHC.Show.Show (Identifier a_808)
  
  instance AST.Unmarshal.Unmarshal Identifier
  
  instance Data.Foldable.Foldable Identifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Identifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Identifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousIf = AST.Token.Token "if" 21
  
  type AnonymousImport = AST.Token.Token "import" 2
  
  type AnonymousIn = AST.Token.Token "in" 27
  
  data Integer a = Integer {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_809.
        AST.Traversable1.Class.Traversable1 a_809
      )
  
  instance AST.Unmarshal.SymbolMatching Integer where
    matchedSymbols _ = [87]
    showFailure _ node_810 =
      "expected "
        GHC.Base.<> ( "integer"
                        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 (Integer a_815)
  
  deriving instance GHC.Classes.Ord a_816 => GHC.Classes.Ord (Integer a_816)
  
  deriving instance GHC.Show.Show a_817 => GHC.Show.Show (Integer a_817)
  
  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 AnonymousIs = AST.Token.Token "is" 62
  
  type AnonymousLambda = AST.Token.Token "lambda" 63
  
  data None a = None {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_818.
        AST.Traversable1.Class.Traversable1 a_818
      )
  
  instance AST.Unmarshal.SymbolMatching None where
    matchedSymbols _ = [91]
    showFailure _ node_819 =
      "expected "
        GHC.Base.<> ( "none"
                        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 (None a_824)
  
  deriving instance GHC.Classes.Ord a_825 => GHC.Classes.Ord (None a_825)
  
  deriving instance GHC.Show.Show a_826 => GHC.Show.Show (None a_826)
  
  instance AST.Unmarshal.Unmarshal None
  
  instance Data.Foldable.Foldable None where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor None where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable None where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousNonlocal = AST.Token.Token "nonlocal" 38
  
  type AnonymousNot = AST.Token.Token "not" 42
  
  type AnonymousOr = AST.Token.Token "or" 44
  
  type AnonymousPass = AST.Token.Token "pass" 18
  
  type AnonymousPrint = AST.Token.Token "print" 11
  
  type AnonymousRaise = AST.Token.Token "raise" 17
  
  type AnonymousReturn = AST.Token.Token "return" 15
  
  data True a = True {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_827.
        AST.Traversable1.Class.Traversable1 a_827
      )
  
  instance AST.Unmarshal.SymbolMatching True where
    matchedSymbols _ = [89]
    showFailure _ node_828 =
      "expected "
        GHC.Base.<> ( "true"
                        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 (True a_833)
  
  deriving instance GHC.Classes.Ord a_834 => GHC.Classes.Ord (True a_834)
  
  deriving instance GHC.Show.Show a_835 => GHC.Show.Show (True a_835)
  
  instance AST.Unmarshal.Unmarshal True
  
  instance Data.Foldable.Foldable True where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor True where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable True where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousTry = AST.Token.Token "try" 29
  
  data TypeConversion a = TypeConversion {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 TypeConversion where
    matchedSymbols _ = [86]
    showFailure _ node_837 =
      "expected "
        GHC.Base.<> ( "type_conversion"
                        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 (TypeConversion a_842)
  
  deriving instance GHC.Classes.Ord a_843 => GHC.Classes.Ord (TypeConversion a_843)
  
  deriving instance GHC.Show.Show a_844 => GHC.Show.Show (TypeConversion a_844)
  
  instance AST.Unmarshal.Unmarshal TypeConversion
  
  instance Data.Foldable.Foldable TypeConversion where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor TypeConversion where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable TypeConversion where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousWhile = AST.Token.Token "while" 28
  
  type AnonymousWith = AST.Token.Token "with" 32
  
  type AnonymousYield = AST.Token.Token "yield" 77
  
  type AnonymousLBrace = AST.Token.Token "{" 81
  
  type AnonymousPipe = AST.Token.Token "|" 50
  
  type AnonymousPipeEqual = AST.Token.Token "|=" 76
  
  type AnonymousRBrace = AST.Token.Token "}" 82
  
  type AnonymousTilde = AST.Token.Token "~" 54
  