content: -- Language definition for Ruby, 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.Ruby.AST (module Language.Ruby.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.Ruby (getTestCorpusDir)
  import qualified Prelude as GHC.Classes
  
  debugSymbolNames :: [GHC.Base.String]
  debugSymbolNames = debugSymbolNames_0
  
  debugSymbolNames_0 :: [GHC.Base.String]
  debugSymbolNames_0 =
    [ "end",
      "identifier",
      "___END__",
      "uninterpreted",
      "_BEGIN",
      "_{",
      "_}",
      "_END",
      "_def",
      "_(",
      "_)",
      "_.",
      "_::",
      "_,",
      "_|",
      "_;",
      "_*",
      "_**",
      "_&",
      "_:",
      "_=",
      "_class",
      "_<",
      "_module",
      "_end",
      "_return",
      "_yield",
      "_break",
      "_next",
      "_redo",
      "_retry",
      "_if",
      "_unless",
      "_while",
      "_until",
      "_rescue",
      "_for",
      "_in",
      "_do",
      "_case",
      "_when",
      "_elsif",
      "_else",
      "_then",
      "_begin",
      "_ensure",
      "_=>",
      "_[",
      "_]",
      "_::",
      "_&.",
      "_(",
      "_+=",
      "_-=",
      "_*=",
      "_**=",
      "_/=",
      "_||=",
      "_|=",
      "_&&=",
      "_&=",
      "_%=",
      "_>>=",
      "_<<=",
      "_^=",
      "_?",
      "_:",
      "_..",
      "_...",
      "_and",
      "_or",
      "_||",
      "_&&",
      "_<<",
      "_>>",
      "_<=",
      "_>",
      "_>=",
      "_^",
      "_+",
      "_/",
      "_%",
      "_==",
      "_!=",
      "_===",
      "_<=>",
      "_=~",
      "_!~",
      "_defined?",
      "_not",
      "_!",
      "_~",
      "_-",
      "_+@",
      "_-@",
      "_[]",
      "_[]=",
      "_`",
      "_undef",
      "_alias",
      "comment",
      "integer",
      "float",
      "complex",
      "_r",
      "super",
      "self",
      "true",
      "false",
      "nil",
      "constant",
      "instance_variable",
      "class_variable",
      "global_variable",
      "character",
      "_#{",
      "_string_array_token1",
      "escape_sequence",
      "_[",
      "_->",
      "_line_break",
      "_simple_symbol",
      "_\"",
      "_:\"",
      "_`",
      "_/",
      "_%w(",
      "_%i(",
      "_heredoc_body_start",
      "_string_content",
      "_heredoc_content",
      "_string_end",
      "heredoc_end",
      "heredoc_beginning",
      "_&",
      "_*",
      "_-",
      "_-",
      "_*",
      "_<<",
      "symbol",
      "program",
      "_statements",
      "begin_block",
      "end_block",
      "_statement",
      "method",
      "singleton_method",
      "_method_rest",
      "parameters",
      "bare_parameters",
      "block_parameters",
      "_formal_parameter",
      "_simple_formal_parameter",
      "splat_parameter",
      "hash_splat_parameter",
      "block_parameter",
      "keyword_parameter",
      "optional_parameter",
      "class",
      "superclass",
      "singleton_class",
      "module",
      "return",
      "yield",
      "break",
      "next",
      "return",
      "yield",
      "break",
      "next",
      "redo",
      "retry",
      "if_modifier",
      "unless_modifier",
      "while_modifier",
      "until_modifier",
      "rescue_modifier",
      "while",
      "until",
      "for",
      "in",
      "do",
      "case",
      "when",
      "pattern",
      "if",
      "unless",
      "elsif",
      "else",
      "then",
      "begin",
      "ensure",
      "rescue",
      "exceptions",
      "exception_variable",
      "_body_statement",
      "_expression",
      "_arg",
      "_primary",
      "parenthesized_statements",
      "element_reference",
      "scope_resolution",
      "call",
      "method_call",
      "method_call",
      "argument_list",
      "argument_list",
      "_argument_list_with_trailing_comma",
      "_argument",
      "splat_argument",
      "hash_splat_argument",
      "block_argument",
      "do_block",
      "block",
      "assignment",
      "assignment",
      "operator_assignment",
      "operator_assignment",
      "conditional",
      "range",
      "binary",
      "binary",
      "unary",
      "unary",
      "unary",
      "right_assignment_list",
      "left_assignment_list",
      "_mlhs",
      "destructured_left_assignment",
      "rest_assignment",
      "_lhs",
      "_variable",
      "operator",
      "_method_name",
      "setter",
      "undef",
      "alias",
      "rational",
      "chained_string",
      "interpolation",
      "string",
      "subshell",
      "string_array",
      "symbol_array",
      "symbol",
      "regex",
      "heredoc_body",
      "__literal_contents",
      "array",
      "hash",
      "pair",
      "lambda",
      "empty_statement",
      "_terminator",
      "__statements_repeat1",
      "_parameters_repeat1",
      "_block_parameters_repeat1",
      "_for_repeat1",
      "_case_repeat1",
      "_case_repeat2",
      "_when_repeat1",
      "_exceptions_repeat1",
      "__body_statement_repeat1",
      "_command_argument_list_repeat1",
      "__mlhs_repeat1",
      "_undef_repeat1",
      "_chained_string_repeat1",
      "_string_array_repeat1",
      "_symbol_array_repeat1",
      "_heredoc_body_repeat1",
      "_hash_repeat1",
      "_\"",
      "bare_string",
      "bare_symbol",
      "destructured_parameter",
      "lambda_parameters",
      "method_parameters"
    ]
  
  newtype Arg a = Arg {getArg :: ((Primary GHC.Generics.:+: Assignment GHC.Generics.:+: Binary GHC.Generics.:+: Conditional GHC.Generics.:+: OperatorAssignment GHC.Generics.:+: Range GHC.Generics.:+: Unary) 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" (Arg a_2) a_2 where
    getField = AST.Unmarshal.gann GHC.Base.. getArg
  
  deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (Arg a_3)
  
  deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (Arg a_4)
  
  deriving instance GHC.Show.Show a_5 => GHC.Show.Show (Arg a_5)
  
  instance AST.Unmarshal.Unmarshal Arg
  
  instance Data.Foldable.Foldable Arg where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Arg where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Arg where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Lhs a = Lhs {getLhs :: ((Variable GHC.Generics.:+: Call GHC.Generics.:+: ElementReference GHC.Generics.:+: False GHC.Generics.:+: MethodCall GHC.Generics.:+: Nil GHC.Generics.:+: ScopeResolution GHC.Generics.:+: True) 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" (Lhs a_7) a_7 where
    getField = AST.Unmarshal.gann GHC.Base.. getLhs
  
  deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (Lhs a_8)
  
  deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (Lhs a_9)
  
  deriving instance GHC.Show.Show a_10 => GHC.Show.Show (Lhs a_10)
  
  instance AST.Unmarshal.Unmarshal Lhs
  
  instance Data.Foldable.Foldable Lhs where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Lhs where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Lhs where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype MethodName a = MethodName {getMethodName :: ((ClassVariable GHC.Generics.:+: Constant GHC.Generics.:+: GlobalVariable GHC.Generics.:+: Identifier GHC.Generics.:+: InstanceVariable GHC.Generics.:+: Operator GHC.Generics.:+: Setter GHC.Generics.:+: Symbol) 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" (MethodName a_12) a_12 where
    getField = AST.Unmarshal.gann GHC.Base.. getMethodName
  
  deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (MethodName a_13)
  
  deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (MethodName a_14)
  
  deriving instance GHC.Show.Show a_15 => GHC.Show.Show (MethodName a_15)
  
  instance AST.Unmarshal.Unmarshal MethodName
  
  instance Data.Foldable.Foldable MethodName where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodName where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodName where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Primary a = Primary {getPrimary :: ((Lhs GHC.Generics.:+: Array GHC.Generics.:+: Begin GHC.Generics.:+: Break GHC.Generics.:+: Case GHC.Generics.:+: ChainedString GHC.Generics.:+: Character GHC.Generics.:+: Class GHC.Generics.:+: Complex GHC.Generics.:+: Float GHC.Generics.:+: For GHC.Generics.:+: Hash GHC.Generics.:+: HeredocBeginning GHC.Generics.:+: If GHC.Generics.:+: Integer GHC.Generics.:+: Lambda GHC.Generics.:+: Method GHC.Generics.:+: Module GHC.Generics.:+: Next GHC.Generics.:+: ParenthesizedStatements GHC.Generics.:+: Rational GHC.Generics.:+: Redo GHC.Generics.:+: Regex GHC.Generics.:+: Retry GHC.Generics.:+: Return GHC.Generics.:+: SingletonClass GHC.Generics.:+: SingletonMethod GHC.Generics.:+: String GHC.Generics.:+: StringArray GHC.Generics.:+: Subshell GHC.Generics.:+: Symbol GHC.Generics.:+: SymbolArray GHC.Generics.:+: Unary GHC.Generics.:+: Unless GHC.Generics.:+: Until GHC.Generics.:+: While GHC.Generics.:+: Yield) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_16.
        AST.Traversable1.Class.Traversable1 a_16
      )
  
  instance GHC.Records.HasField "ann" (Primary a_17) a_17 where
    getField = AST.Unmarshal.gann GHC.Base.. getPrimary
  
  deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (Primary a_18)
  
  deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (Primary a_19)
  
  deriving instance GHC.Show.Show a_20 => GHC.Show.Show (Primary a_20)
  
  instance AST.Unmarshal.Unmarshal Primary
  
  instance Data.Foldable.Foldable Primary where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Primary where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Primary where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Statement a = Statement {getStatement :: ((Arg GHC.Generics.:+: Alias GHC.Generics.:+: Assignment GHC.Generics.:+: BeginBlock GHC.Generics.:+: Binary GHC.Generics.:+: Break GHC.Generics.:+: EndBlock GHC.Generics.:+: IfModifier GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: OperatorAssignment GHC.Generics.:+: RescueModifier GHC.Generics.:+: Return GHC.Generics.:+: Undef GHC.Generics.:+: UnlessModifier GHC.Generics.:+: UntilModifier GHC.Generics.:+: WhileModifier GHC.Generics.:+: Yield) 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" (Statement a_22) a_22 where
    getField = AST.Unmarshal.gann GHC.Base.. getStatement
  
  deriving instance GHC.Classes.Eq a_23 => GHC.Classes.Eq (Statement a_23)
  
  deriving instance GHC.Classes.Ord a_24 => GHC.Classes.Ord (Statement a_24)
  
  deriving instance GHC.Show.Show a_25 => GHC.Show.Show (Statement a_25)
  
  instance AST.Unmarshal.Unmarshal Statement
  
  instance Data.Foldable.Foldable Statement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Statement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Statement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  newtype Variable a = Variable {getVariable :: ((ClassVariable GHC.Generics.:+: Constant GHC.Generics.:+: GlobalVariable GHC.Generics.:+: Identifier GHC.Generics.:+: InstanceVariable GHC.Generics.:+: Self GHC.Generics.:+: Super) a)}
    deriving newtype (AST.Unmarshal.SymbolMatching)
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_26.
        AST.Traversable1.Class.Traversable1 a_26
      )
  
  instance GHC.Records.HasField "ann" (Variable a_27) a_27 where
    getField = AST.Unmarshal.gann GHC.Base.. getVariable
  
  deriving instance GHC.Classes.Eq a_28 => GHC.Classes.Eq (Variable a_28)
  
  deriving instance GHC.Classes.Ord a_29 => GHC.Classes.Ord (Variable a_29)
  
  deriving instance GHC.Show.Show a_30 => GHC.Show.Show (Variable a_30)
  
  instance AST.Unmarshal.Unmarshal Variable
  
  instance Data.Foldable.Foldable Variable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Variable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Variable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Alias a = Alias
    { ann :: a,
      alias :: (AST.Parse.Err (MethodName a)),
      name :: (AST.Parse.Err (MethodName a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_31.
        AST.Traversable1.Class.Traversable1 a_31
      )
  
  instance AST.Unmarshal.SymbolMatching Alias where
    matchedSymbols _ = [237]
    showFailure _ node_32 =
      "expected "
        GHC.Base.<> ( "alias"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_32 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_32) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_33 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_34 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_35 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_36 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_33
          c1_34 = TreeSitter.Node.nodeStartPoint node_32
        TreeSitter.Node.TSPoint
          r2_35
          c2_36 = TreeSitter.Node.nodeEndPoint node_32
  
  deriving instance GHC.Classes.Eq a_37 => GHC.Classes.Eq (Alias a_37)
  
  deriving instance GHC.Classes.Ord a_38 => GHC.Classes.Ord (Alias a_38)
  
  deriving instance GHC.Show.Show a_39 => GHC.Show.Show (Alias a_39)
  
  instance AST.Unmarshal.Unmarshal Alias
  
  instance Data.Foldable.Foldable Alias where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Alias where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Alias where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ArgumentList a = ArgumentList
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Arg GHC.Generics.:+: BlockArgument GHC.Generics.:+: HashSplatArgument GHC.Generics.:+: MethodCall GHC.Generics.:+: Pair GHC.Generics.:+: SplatArgument) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_40.
        AST.Traversable1.Class.Traversable1 a_40
      )
  
  instance AST.Unmarshal.SymbolMatching ArgumentList where
    matchedSymbols _ = [206, 207]
    showFailure _ node_41 =
      "expected "
        GHC.Base.<> ( "argument_list, argument_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_41 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_41) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_42 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_43 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_44 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_45 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_42
          c1_43 = TreeSitter.Node.nodeStartPoint node_41
        TreeSitter.Node.TSPoint
          r2_44
          c2_45 = TreeSitter.Node.nodeEndPoint node_41
  
  deriving instance GHC.Classes.Eq a_46 => GHC.Classes.Eq (ArgumentList a_46)
  
  deriving instance GHC.Classes.Ord a_47 => GHC.Classes.Ord (ArgumentList a_47)
  
  deriving instance GHC.Show.Show a_48 => GHC.Show.Show (ArgumentList a_48)
  
  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 Array a = Array
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Arg GHC.Generics.:+: BlockArgument GHC.Generics.:+: HashSplatArgument GHC.Generics.:+: Pair GHC.Generics.:+: SplatArgument) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_49.
        AST.Traversable1.Class.Traversable1 a_49
      )
  
  instance AST.Unmarshal.SymbolMatching Array where
    matchedSymbols _ = [249]
    showFailure _ node_50 =
      "expected "
        GHC.Base.<> ( "array"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_50 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_50) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_51 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_52 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_53 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_54 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_51
          c1_52 = TreeSitter.Node.nodeStartPoint node_50
        TreeSitter.Node.TSPoint
          r2_53
          c2_54 = TreeSitter.Node.nodeEndPoint node_50
  
  deriving instance GHC.Classes.Eq a_55 => GHC.Classes.Eq (Array a_55)
  
  deriving instance GHC.Classes.Ord a_56 => GHC.Classes.Ord (Array a_56)
  
  deriving instance GHC.Show.Show a_57 => GHC.Show.Show (Array a_57)
  
  instance AST.Unmarshal.Unmarshal Array
  
  instance Data.Foldable.Foldable Array where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Array where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Array where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Assignment a = Assignment
    { ann :: a,
      left :: (AST.Parse.Err ((Lhs GHC.Generics.:+: LeftAssignmentList) a)),
      right :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: RightAssignmentList GHC.Generics.:+: SplatArgument GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_58.
        AST.Traversable1.Class.Traversable1 a_58
      )
  
  instance AST.Unmarshal.SymbolMatching Assignment where
    matchedSymbols _ = [215, 216]
    showFailure _ node_59 =
      "expected "
        GHC.Base.<> ( "assignment, assignment"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_59 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_59) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_60 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_61 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_62 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_63 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_60
          c1_61 = TreeSitter.Node.nodeStartPoint node_59
        TreeSitter.Node.TSPoint
          r2_62
          c2_63 = TreeSitter.Node.nodeEndPoint node_59
  
  deriving instance GHC.Classes.Eq a_64 => GHC.Classes.Eq (Assignment a_64)
  
  deriving instance GHC.Classes.Ord a_65 => GHC.Classes.Ord (Assignment a_65)
  
  deriving instance GHC.Show.Show a_66 => GHC.Show.Show (Assignment a_66)
  
  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 BareString a = BareString
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_67.
        AST.Traversable1.Class.Traversable1 a_67
      )
  
  instance AST.Unmarshal.SymbolMatching BareString where
    matchedSymbols _ = [273]
    showFailure _ node_68 =
      "expected "
        GHC.Base.<> ( "bare_string"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_68 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_68) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_69 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_70 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_71 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_72 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_69
          c1_70 = TreeSitter.Node.nodeStartPoint node_68
        TreeSitter.Node.TSPoint
          r2_71
          c2_72 = TreeSitter.Node.nodeEndPoint node_68
  
  deriving instance GHC.Classes.Eq a_73 => GHC.Classes.Eq (BareString a_73)
  
  deriving instance GHC.Classes.Ord a_74 => GHC.Classes.Ord (BareString a_74)
  
  deriving instance GHC.Show.Show a_75 => GHC.Show.Show (BareString a_75)
  
  instance AST.Unmarshal.Unmarshal BareString
  
  instance Data.Foldable.Foldable BareString where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BareString where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BareString where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BareSymbol a = BareSymbol
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_76.
        AST.Traversable1.Class.Traversable1 a_76
      )
  
  instance AST.Unmarshal.SymbolMatching BareSymbol where
    matchedSymbols _ = [274]
    showFailure _ node_77 =
      "expected "
        GHC.Base.<> ( "bare_symbol"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_77 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_77) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_78 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_79 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_80 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_81 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_78
          c1_79 = TreeSitter.Node.nodeStartPoint node_77
        TreeSitter.Node.TSPoint
          r2_80
          c2_81 = TreeSitter.Node.nodeEndPoint node_77
  
  deriving instance GHC.Classes.Eq a_82 => GHC.Classes.Eq (BareSymbol a_82)
  
  deriving instance GHC.Classes.Ord a_83 => GHC.Classes.Ord (BareSymbol a_83)
  
  deriving instance GHC.Show.Show a_84 => GHC.Show.Show (BareSymbol a_84)
  
  instance AST.Unmarshal.Unmarshal BareSymbol
  
  instance Data.Foldable.Foldable BareSymbol where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BareSymbol where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BareSymbol where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Begin a = Begin
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_85.
        AST.Traversable1.Class.Traversable1 a_85
      )
  
  instance AST.Unmarshal.SymbolMatching Begin where
    matchedSymbols _ = [191]
    showFailure _ node_86 =
      "expected "
        GHC.Base.<> ( "begin"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_86 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_86) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_87 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_88 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_89 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_90 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_87
          c1_88 = TreeSitter.Node.nodeStartPoint node_86
        TreeSitter.Node.TSPoint
          r2_89
          c2_90 = TreeSitter.Node.nodeEndPoint node_86
  
  deriving instance GHC.Classes.Eq a_91 => GHC.Classes.Eq (Begin a_91)
  
  deriving instance GHC.Classes.Ord a_92 => GHC.Classes.Ord (Begin a_92)
  
  deriving instance GHC.Show.Show a_93 => GHC.Show.Show (Begin a_93)
  
  instance AST.Unmarshal.Unmarshal Begin
  
  instance Data.Foldable.Foldable Begin where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Begin where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Begin where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BeginBlock a = BeginBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_94.
        AST.Traversable1.Class.Traversable1 a_94
      )
  
  instance AST.Unmarshal.SymbolMatching BeginBlock where
    matchedSymbols _ = [143]
    showFailure _ node_95 =
      "expected "
        GHC.Base.<> ( "begin_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_95 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_95) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_96 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_97 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_98 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_99 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_96
          c1_97 = TreeSitter.Node.nodeStartPoint node_95
        TreeSitter.Node.TSPoint
          r2_98
          c2_99 = TreeSitter.Node.nodeEndPoint node_95
  
  deriving instance GHC.Classes.Eq a_100 => GHC.Classes.Eq (BeginBlock a_100)
  
  deriving instance GHC.Classes.Ord a_101 => GHC.Classes.Ord (BeginBlock a_101)
  
  deriving instance GHC.Show.Show a_102 => GHC.Show.Show (BeginBlock a_102)
  
  instance AST.Unmarshal.Unmarshal BeginBlock
  
  instance Data.Foldable.Foldable BeginBlock where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BeginBlock where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BeginBlock where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Binary a = Binary
    { ann :: a,
      operator :: (AST.Parse.Err ((AnonymousBangEqual GHC.Generics.:+: AnonymousBangTilde GHC.Generics.:+: AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousAmpersandAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousStarStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousLAngle GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousLAngleEqual GHC.Generics.:+: AnonymousLAngleEqualRAngle GHC.Generics.:+: AnonymousEqualEqual GHC.Generics.:+: AnonymousEqualEqualEqual GHC.Generics.:+: AnonymousEqualTilde GHC.Generics.:+: AnonymousRAngle GHC.Generics.:+: AnonymousRAngleEqual GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousAnd GHC.Generics.:+: AnonymousOr GHC.Generics.:+: AnonymousPipe GHC.Generics.:+: AnonymousPipePipe) a)),
      left :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a)),
      right :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_103.
        AST.Traversable1.Class.Traversable1 a_103
      )
  
  instance AST.Unmarshal.SymbolMatching Binary where
    matchedSymbols _ = [221, 222]
    showFailure _ node_104 =
      "expected "
        GHC.Base.<> ( "binary, binary"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_104 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_104) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_105 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_106 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_107 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_108 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_105
          c1_106 = TreeSitter.Node.nodeStartPoint node_104
        TreeSitter.Node.TSPoint
          r2_107
          c2_108 = TreeSitter.Node.nodeEndPoint node_104
  
  deriving instance GHC.Classes.Eq a_109 => GHC.Classes.Eq (Binary a_109)
  
  deriving instance GHC.Classes.Ord a_110 => GHC.Classes.Ord (Binary a_110)
  
  deriving instance GHC.Show.Show a_111 => GHC.Show.Show (Binary a_111)
  
  instance AST.Unmarshal.Unmarshal Binary
  
  instance Data.Foldable.Foldable Binary where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Binary where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Binary where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Block a = Block
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: BlockParameters GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_112.
        AST.Traversable1.Class.Traversable1 a_112
      )
  
  instance AST.Unmarshal.SymbolMatching Block where
    matchedSymbols _ = [214]
    showFailure _ node_113 =
      "expected "
        GHC.Base.<> ( "block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_113 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_113) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_114 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_115 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_116 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_117 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_114
          c1_115 = TreeSitter.Node.nodeStartPoint node_113
        TreeSitter.Node.TSPoint
          r2_116
          c2_117 = TreeSitter.Node.nodeEndPoint node_113
  
  deriving instance GHC.Classes.Eq a_118 => GHC.Classes.Eq (Block a_118)
  
  deriving instance GHC.Classes.Ord a_119 => GHC.Classes.Ord (Block a_119)
  
  deriving instance GHC.Show.Show a_120 => GHC.Show.Show (Block a_120)
  
  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 BlockArgument a = BlockArgument
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_121.
        AST.Traversable1.Class.Traversable1 a_121
      )
  
  instance AST.Unmarshal.SymbolMatching BlockArgument where
    matchedSymbols _ = [212]
    showFailure _ node_122 =
      "expected "
        GHC.Base.<> ( "block_argument"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_122 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_122) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_123 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_124 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_125 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_126 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_123
          c1_124 = TreeSitter.Node.nodeStartPoint node_122
        TreeSitter.Node.TSPoint
          r2_125
          c2_126 = TreeSitter.Node.nodeEndPoint node_122
  
  deriving instance GHC.Classes.Eq a_127 => GHC.Classes.Eq (BlockArgument a_127)
  
  deriving instance GHC.Classes.Ord a_128 => GHC.Classes.Ord (BlockArgument a_128)
  
  deriving instance GHC.Show.Show a_129 => GHC.Show.Show (BlockArgument a_129)
  
  instance AST.Unmarshal.Unmarshal BlockArgument
  
  instance Data.Foldable.Foldable BlockArgument where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BlockArgument where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BlockArgument where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BlockParameter a = BlockParameter {ann :: a, name :: (AST.Parse.Err (Identifier a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_130.
        AST.Traversable1.Class.Traversable1 a_130
      )
  
  instance AST.Unmarshal.SymbolMatching BlockParameter where
    matchedSymbols _ = [156]
    showFailure _ node_131 =
      "expected "
        GHC.Base.<> ( "block_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_131 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_131) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_132 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_133 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_134 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_135 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_132
          c1_133 = TreeSitter.Node.nodeStartPoint node_131
        TreeSitter.Node.TSPoint
          r2_134
          c2_135 = TreeSitter.Node.nodeEndPoint node_131
  
  deriving instance GHC.Classes.Eq a_136 => GHC.Classes.Eq (BlockParameter a_136)
  
  deriving instance GHC.Classes.Ord a_137 => GHC.Classes.Ord (BlockParameter a_137)
  
  deriving instance GHC.Show.Show a_138 => GHC.Show.Show (BlockParameter a_138)
  
  instance AST.Unmarshal.Unmarshal BlockParameter
  
  instance Data.Foldable.Foldable BlockParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BlockParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BlockParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data BlockParameters a = BlockParameters
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((BlockParameter GHC.Generics.:+: DestructuredParameter GHC.Generics.:+: HashSplatParameter GHC.Generics.:+: Identifier GHC.Generics.:+: KeywordParameter GHC.Generics.:+: OptionalParameter GHC.Generics.:+: SplatParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_139.
        AST.Traversable1.Class.Traversable1 a_139
      )
  
  instance AST.Unmarshal.SymbolMatching BlockParameters where
    matchedSymbols _ = [151]
    showFailure _ node_140 =
      "expected "
        GHC.Base.<> ( "block_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_140 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_140) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_141 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_142 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_143 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_144 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_141
          c1_142 = TreeSitter.Node.nodeStartPoint node_140
        TreeSitter.Node.TSPoint
          r2_143
          c2_144 = TreeSitter.Node.nodeEndPoint node_140
  
  deriving instance GHC.Classes.Eq a_145 => GHC.Classes.Eq (BlockParameters a_145)
  
  deriving instance GHC.Classes.Ord a_146 => GHC.Classes.Ord (BlockParameters a_146)
  
  deriving instance GHC.Show.Show a_147 => GHC.Show.Show (BlockParameters a_147)
  
  instance AST.Unmarshal.Unmarshal BlockParameters
  
  instance Data.Foldable.Foldable BlockParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor BlockParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable BlockParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Break a = Break
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_148.
        AST.Traversable1.Class.Traversable1 a_148
      )
  
  instance AST.Unmarshal.SymbolMatching Break where
    matchedSymbols _ = [165, 169]
    showFailure _ node_149 =
      "expected "
        GHC.Base.<> ( "break, break"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_149 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_149) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_150 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_151 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_152 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_153 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_150
          c1_151 = TreeSitter.Node.nodeStartPoint node_149
        TreeSitter.Node.TSPoint
          r2_152
          c2_153 = TreeSitter.Node.nodeEndPoint node_149
  
  deriving instance GHC.Classes.Eq a_154 => GHC.Classes.Eq (Break a_154)
  
  deriving instance GHC.Classes.Ord a_155 => GHC.Classes.Ord (Break a_155)
  
  deriving instance GHC.Show.Show a_156 => GHC.Show.Show (Break a_156)
  
  instance AST.Unmarshal.Unmarshal Break
  
  instance Data.Foldable.Foldable Break where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Break where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Break where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Call a = Call
    { ann :: a,
      receiver :: (AST.Parse.Err (Primary a)),
      method :: (AST.Parse.Err ((ArgumentList GHC.Generics.:+: Constant GHC.Generics.:+: Identifier GHC.Generics.:+: Operator) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_157.
        AST.Traversable1.Class.Traversable1 a_157
      )
  
  instance AST.Unmarshal.SymbolMatching Call where
    matchedSymbols _ = [203]
    showFailure _ node_158 =
      "expected "
        GHC.Base.<> ( "call"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_158 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_158) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_159 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_160 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_161 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_162 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_159
          c1_160 = TreeSitter.Node.nodeStartPoint node_158
        TreeSitter.Node.TSPoint
          r2_161
          c2_162 = TreeSitter.Node.nodeEndPoint node_158
  
  deriving instance GHC.Classes.Eq a_163 => GHC.Classes.Eq (Call a_163)
  
  deriving instance GHC.Classes.Ord a_164 => GHC.Classes.Ord (Call a_164)
  
  deriving instance GHC.Show.Show a_165 => GHC.Show.Show (Call a_165)
  
  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 Case a = Case
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err (Arg a))),
      extraChildren :: ([AST.Parse.Err ((Else GHC.Generics.:+: When) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_166.
        AST.Traversable1.Class.Traversable1 a_166
      )
  
  instance AST.Unmarshal.SymbolMatching Case where
    matchedSymbols _ = [183]
    showFailure _ node_167 =
      "expected "
        GHC.Base.<> ( "case"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_167 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_167) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_168 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_169 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_170 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_171 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_168
          c1_169 = TreeSitter.Node.nodeStartPoint node_167
        TreeSitter.Node.TSPoint
          r2_170
          c2_171 = TreeSitter.Node.nodeEndPoint node_167
  
  deriving instance GHC.Classes.Eq a_172 => GHC.Classes.Eq (Case a_172)
  
  deriving instance GHC.Classes.Ord a_173 => GHC.Classes.Ord (Case a_173)
  
  deriving instance GHC.Show.Show a_174 => GHC.Show.Show (Case a_174)
  
  instance AST.Unmarshal.Unmarshal Case
  
  instance Data.Foldable.Foldable Case where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Case where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Case where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ChainedString a = ChainedString
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (String a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_175.
        AST.Traversable1.Class.Traversable1 a_175
      )
  
  instance AST.Unmarshal.SymbolMatching ChainedString where
    matchedSymbols _ = [239]
    showFailure _ node_176 =
      "expected "
        GHC.Base.<> ( "chained_string"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_176 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_176) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_177 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_178 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_179 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_180 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_177
          c1_178 = TreeSitter.Node.nodeStartPoint node_176
        TreeSitter.Node.TSPoint
          r2_179
          c2_180 = TreeSitter.Node.nodeEndPoint node_176
  
  deriving instance GHC.Classes.Eq a_181 => GHC.Classes.Eq (ChainedString a_181)
  
  deriving instance GHC.Classes.Ord a_182 => GHC.Classes.Ord (ChainedString a_182)
  
  deriving instance GHC.Show.Show a_183 => GHC.Show.Show (ChainedString a_183)
  
  instance AST.Unmarshal.Unmarshal ChainedString
  
  instance Data.Foldable.Foldable ChainedString where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ChainedString where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ChainedString where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Class a = Class
    { ann :: a,
      name :: (AST.Parse.Err ((Constant GHC.Generics.:+: ScopeResolution) a)),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue GHC.Generics.:+: Superclass) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_184.
        AST.Traversable1.Class.Traversable1 a_184
      )
  
  instance AST.Unmarshal.SymbolMatching Class where
    matchedSymbols _ = [159]
    showFailure _ node_185 =
      "expected "
        GHC.Base.<> ( "class"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_185 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_185) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_186 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_187 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_188 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_189 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_186
          c1_187 = TreeSitter.Node.nodeStartPoint node_185
        TreeSitter.Node.TSPoint
          r2_188
          c2_189 = TreeSitter.Node.nodeEndPoint node_185
  
  deriving instance GHC.Classes.Eq a_190 => GHC.Classes.Eq (Class a_190)
  
  deriving instance GHC.Classes.Ord a_191 => GHC.Classes.Ord (Class a_191)
  
  deriving instance GHC.Show.Show a_192 => GHC.Show.Show (Class a_192)
  
  instance AST.Unmarshal.Unmarshal Class
  
  instance Data.Foldable.Foldable Class where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Class where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Class where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Conditional a = Conditional
    { ann :: a,
      alternative :: (AST.Parse.Err (Arg a)),
      consequence :: (AST.Parse.Err (Arg a)),
      condition :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_193.
        AST.Traversable1.Class.Traversable1 a_193
      )
  
  instance AST.Unmarshal.SymbolMatching Conditional where
    matchedSymbols _ = [219]
    showFailure _ node_194 =
      "expected "
        GHC.Base.<> ( "conditional"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_194 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_194) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_195 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_196 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_197 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_198 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_195
          c1_196 = TreeSitter.Node.nodeStartPoint node_194
        TreeSitter.Node.TSPoint
          r2_197
          c2_198 = TreeSitter.Node.nodeEndPoint node_194
  
  deriving instance GHC.Classes.Eq a_199 => GHC.Classes.Eq (Conditional a_199)
  
  deriving instance GHC.Classes.Ord a_200 => GHC.Classes.Ord (Conditional a_200)
  
  deriving instance GHC.Show.Show a_201 => GHC.Show.Show (Conditional a_201)
  
  instance AST.Unmarshal.Unmarshal Conditional
  
  instance Data.Foldable.Foldable Conditional where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Conditional where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Conditional where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DestructuredLeftAssignment a = DestructuredLeftAssignment
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Lhs GHC.Generics.:+: DestructuredLeftAssignment GHC.Generics.:+: RestAssignment) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_202.
        AST.Traversable1.Class.Traversable1 a_202
      )
  
  instance AST.Unmarshal.SymbolMatching DestructuredLeftAssignment where
    matchedSymbols _ = [229]
    showFailure _ node_203 =
      "expected "
        GHC.Base.<> ( "destructured_left_assignment"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_203 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_203) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_204 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_205 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_206 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_207 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_204
          c1_205 = TreeSitter.Node.nodeStartPoint node_203
        TreeSitter.Node.TSPoint
          r2_206
          c2_207 = TreeSitter.Node.nodeEndPoint node_203
  
  deriving instance GHC.Classes.Eq a_208 => GHC.Classes.Eq (DestructuredLeftAssignment a_208)
  
  deriving instance GHC.Classes.Ord a_209 => GHC.Classes.Ord (DestructuredLeftAssignment a_209)
  
  deriving instance GHC.Show.Show a_210 => GHC.Show.Show (DestructuredLeftAssignment a_210)
  
  instance AST.Unmarshal.Unmarshal DestructuredLeftAssignment
  
  instance Data.Foldable.Foldable DestructuredLeftAssignment where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DestructuredLeftAssignment where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DestructuredLeftAssignment where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DestructuredParameter a = DestructuredParameter
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((BlockParameter GHC.Generics.:+: DestructuredParameter GHC.Generics.:+: HashSplatParameter GHC.Generics.:+: Identifier GHC.Generics.:+: KeywordParameter GHC.Generics.:+: OptionalParameter GHC.Generics.:+: SplatParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_211.
        AST.Traversable1.Class.Traversable1 a_211
      )
  
  instance AST.Unmarshal.SymbolMatching DestructuredParameter where
    matchedSymbols _ = [275]
    showFailure _ node_212 =
      "expected "
        GHC.Base.<> ( "destructured_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_212 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_212) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_213 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_214 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_215 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_216 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_213
          c1_214 = TreeSitter.Node.nodeStartPoint node_212
        TreeSitter.Node.TSPoint
          r2_215
          c2_216 = TreeSitter.Node.nodeEndPoint node_212
  
  deriving instance GHC.Classes.Eq a_217 => GHC.Classes.Eq (DestructuredParameter a_217)
  
  deriving instance GHC.Classes.Ord a_218 => GHC.Classes.Ord (DestructuredParameter a_218)
  
  deriving instance GHC.Show.Show a_219 => GHC.Show.Show (DestructuredParameter a_219)
  
  instance AST.Unmarshal.Unmarshal DestructuredParameter
  
  instance Data.Foldable.Foldable DestructuredParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DestructuredParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DestructuredParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Do a = Do
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_220.
        AST.Traversable1.Class.Traversable1 a_220
      )
  
  instance AST.Unmarshal.SymbolMatching Do where
    matchedSymbols _ = [182]
    showFailure _ node_221 =
      "expected "
        GHC.Base.<> ( "do"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_221 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_221) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_222 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_223 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_224 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_225 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_222
          c1_223 = TreeSitter.Node.nodeStartPoint node_221
        TreeSitter.Node.TSPoint
          r2_224
          c2_225 = TreeSitter.Node.nodeEndPoint node_221
  
  deriving instance GHC.Classes.Eq a_226 => GHC.Classes.Eq (Do a_226)
  
  deriving instance GHC.Classes.Ord a_227 => GHC.Classes.Ord (Do a_227)
  
  deriving instance GHC.Show.Show a_228 => GHC.Show.Show (Do a_228)
  
  instance AST.Unmarshal.Unmarshal Do
  
  instance Data.Foldable.Foldable Do where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Do where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Do where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data DoBlock a = DoBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: BlockParameters GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_229.
        AST.Traversable1.Class.Traversable1 a_229
      )
  
  instance AST.Unmarshal.SymbolMatching DoBlock where
    matchedSymbols _ = [213]
    showFailure _ node_230 =
      "expected "
        GHC.Base.<> ( "do_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_230 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_230) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_231 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_232 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_233 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_234 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_231
          c1_232 = TreeSitter.Node.nodeStartPoint node_230
        TreeSitter.Node.TSPoint
          r2_233
          c2_234 = TreeSitter.Node.nodeEndPoint node_230
  
  deriving instance GHC.Classes.Eq a_235 => GHC.Classes.Eq (DoBlock a_235)
  
  deriving instance GHC.Classes.Ord a_236 => GHC.Classes.Ord (DoBlock a_236)
  
  deriving instance GHC.Show.Show a_237 => GHC.Show.Show (DoBlock a_237)
  
  instance AST.Unmarshal.Unmarshal DoBlock
  
  instance Data.Foldable.Foldable DoBlock where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor DoBlock where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable DoBlock where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ElementReference a = ElementReference
    { ann :: a,
      object :: (AST.Parse.Err (Primary a)),
      extraChildren :: ([AST.Parse.Err ((Arg GHC.Generics.:+: BlockArgument GHC.Generics.:+: HashSplatArgument GHC.Generics.:+: Pair GHC.Generics.:+: SplatArgument) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_238.
        AST.Traversable1.Class.Traversable1 a_238
      )
  
  instance AST.Unmarshal.SymbolMatching ElementReference where
    matchedSymbols _ = [201]
    showFailure _ node_239 =
      "expected "
        GHC.Base.<> ( "element_reference"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_239 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_239) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_240 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_241 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_242 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_243 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_240
          c1_241 = TreeSitter.Node.nodeStartPoint node_239
        TreeSitter.Node.TSPoint
          r2_242
          c2_243 = TreeSitter.Node.nodeEndPoint node_239
  
  deriving instance GHC.Classes.Eq a_244 => GHC.Classes.Eq (ElementReference a_244)
  
  deriving instance GHC.Classes.Ord a_245 => GHC.Classes.Ord (ElementReference a_245)
  
  deriving instance GHC.Show.Show a_246 => GHC.Show.Show (ElementReference a_246)
  
  instance AST.Unmarshal.Unmarshal ElementReference
  
  instance Data.Foldable.Foldable ElementReference where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ElementReference where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ElementReference where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Else a = Else
    { ann :: a,
      condition :: (GHC.Maybe.Maybe (AST.Parse.Err (AnonymousSemicolon a))),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_247.
        AST.Traversable1.Class.Traversable1 a_247
      )
  
  instance AST.Unmarshal.SymbolMatching Else where
    matchedSymbols _ = [189]
    showFailure _ node_248 =
      "expected "
        GHC.Base.<> ( "else"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_248 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_248) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_249 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_250 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_251 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_252 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_249
          c1_250 = TreeSitter.Node.nodeStartPoint node_248
        TreeSitter.Node.TSPoint
          r2_251
          c2_252 = TreeSitter.Node.nodeEndPoint node_248
  
  deriving instance GHC.Classes.Eq a_253 => GHC.Classes.Eq (Else a_253)
  
  deriving instance GHC.Classes.Ord a_254 => GHC.Classes.Ord (Else a_254)
  
  deriving instance GHC.Show.Show a_255 => GHC.Show.Show (Else a_255)
  
  instance AST.Unmarshal.Unmarshal Else
  
  instance Data.Foldable.Foldable Else where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Else where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Else where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Elsif a = Elsif
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err ((Else GHC.Generics.:+: Elsif) a))),
      consequence :: (GHC.Maybe.Maybe (AST.Parse.Err (Then a))),
      condition :: (AST.Parse.Err (Statement a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_256.
        AST.Traversable1.Class.Traversable1 a_256
      )
  
  instance AST.Unmarshal.SymbolMatching Elsif where
    matchedSymbols _ = [188]
    showFailure _ node_257 =
      "expected "
        GHC.Base.<> ( "elsif"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_257 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_257) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_258 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_259 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_260 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_261 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_258
          c1_259 = TreeSitter.Node.nodeStartPoint node_257
        TreeSitter.Node.TSPoint
          r2_260
          c2_261 = TreeSitter.Node.nodeEndPoint node_257
  
  deriving instance GHC.Classes.Eq a_262 => GHC.Classes.Eq (Elsif a_262)
  
  deriving instance GHC.Classes.Ord a_263 => GHC.Classes.Ord (Elsif a_263)
  
  deriving instance GHC.Show.Show a_264 => GHC.Show.Show (Elsif a_264)
  
  instance AST.Unmarshal.Unmarshal Elsif
  
  instance Data.Foldable.Foldable Elsif where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Elsif where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Elsif where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EmptyStatement a = EmptyStatement {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_265.
        AST.Traversable1.Class.Traversable1 a_265
      )
  
  instance AST.Unmarshal.SymbolMatching EmptyStatement where
    matchedSymbols _ = [253]
    showFailure _ node_266 =
      "expected "
        GHC.Base.<> ( "empty_statement"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_266 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_266) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_267 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_268 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_269 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_270 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_267
          c1_268 = TreeSitter.Node.nodeStartPoint node_266
        TreeSitter.Node.TSPoint
          r2_269
          c2_270 = TreeSitter.Node.nodeEndPoint node_266
  
  deriving instance GHC.Classes.Eq a_271 => GHC.Classes.Eq (EmptyStatement a_271)
  
  deriving instance GHC.Classes.Ord a_272 => GHC.Classes.Ord (EmptyStatement a_272)
  
  deriving instance GHC.Show.Show a_273 => GHC.Show.Show (EmptyStatement a_273)
  
  instance AST.Unmarshal.Unmarshal EmptyStatement
  
  instance Data.Foldable.Foldable EmptyStatement where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EmptyStatement where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EmptyStatement where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data EndBlock a = EndBlock
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_274.
        AST.Traversable1.Class.Traversable1 a_274
      )
  
  instance AST.Unmarshal.SymbolMatching EndBlock where
    matchedSymbols _ = [144]
    showFailure _ node_275 =
      "expected "
        GHC.Base.<> ( "end_block"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_275 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_275) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_276 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_277 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_278 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_279 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_276
          c1_277 = TreeSitter.Node.nodeStartPoint node_275
        TreeSitter.Node.TSPoint
          r2_278
          c2_279 = TreeSitter.Node.nodeEndPoint node_275
  
  deriving instance GHC.Classes.Eq a_280 => GHC.Classes.Eq (EndBlock a_280)
  
  deriving instance GHC.Classes.Ord a_281 => GHC.Classes.Ord (EndBlock a_281)
  
  deriving instance GHC.Show.Show a_282 => GHC.Show.Show (EndBlock a_282)
  
  instance AST.Unmarshal.Unmarshal EndBlock
  
  instance Data.Foldable.Foldable EndBlock where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor EndBlock where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable EndBlock where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Ensure a = Ensure
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_283.
        AST.Traversable1.Class.Traversable1 a_283
      )
  
  instance AST.Unmarshal.SymbolMatching Ensure where
    matchedSymbols _ = [192]
    showFailure _ node_284 =
      "expected "
        GHC.Base.<> ( "ensure"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_284 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_284) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_285 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_286 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_287 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_288 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_285
          c1_286 = TreeSitter.Node.nodeStartPoint node_284
        TreeSitter.Node.TSPoint
          r2_287
          c2_288 = TreeSitter.Node.nodeEndPoint node_284
  
  deriving instance GHC.Classes.Eq a_289 => GHC.Classes.Eq (Ensure a_289)
  
  deriving instance GHC.Classes.Ord a_290 => GHC.Classes.Ord (Ensure a_290)
  
  deriving instance GHC.Show.Show a_291 => GHC.Show.Show (Ensure a_291)
  
  instance AST.Unmarshal.Unmarshal Ensure
  
  instance Data.Foldable.Foldable Ensure where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Ensure where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Ensure where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ExceptionVariable a = ExceptionVariable
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Lhs a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_292.
        AST.Traversable1.Class.Traversable1 a_292
      )
  
  instance AST.Unmarshal.SymbolMatching ExceptionVariable where
    matchedSymbols _ = [195]
    showFailure _ node_293 =
      "expected "
        GHC.Base.<> ( "exception_variable"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_293 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_293) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_294 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_295 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_296 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_297 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_294
          c1_295 = TreeSitter.Node.nodeStartPoint node_293
        TreeSitter.Node.TSPoint
          r2_296
          c2_297 = TreeSitter.Node.nodeEndPoint node_293
  
  deriving instance GHC.Classes.Eq a_298 => GHC.Classes.Eq (ExceptionVariable a_298)
  
  deriving instance GHC.Classes.Ord a_299 => GHC.Classes.Ord (ExceptionVariable a_299)
  
  deriving instance GHC.Show.Show a_300 => GHC.Show.Show (ExceptionVariable a_300)
  
  instance AST.Unmarshal.Unmarshal ExceptionVariable
  
  instance Data.Foldable.Foldable ExceptionVariable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ExceptionVariable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ExceptionVariable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Exceptions a = Exceptions
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Arg GHC.Generics.:+: SplatArgument) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_301.
        AST.Traversable1.Class.Traversable1 a_301
      )
  
  instance AST.Unmarshal.SymbolMatching Exceptions where
    matchedSymbols _ = [194]
    showFailure _ node_302 =
      "expected "
        GHC.Base.<> ( "exceptions"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_302 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_302) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_303 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_304 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_305 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_306 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_303
          c1_304 = TreeSitter.Node.nodeStartPoint node_302
        TreeSitter.Node.TSPoint
          r2_305
          c2_306 = TreeSitter.Node.nodeEndPoint node_302
  
  deriving instance GHC.Classes.Eq a_307 => GHC.Classes.Eq (Exceptions a_307)
  
  deriving instance GHC.Classes.Ord a_308 => GHC.Classes.Ord (Exceptions a_308)
  
  deriving instance GHC.Show.Show a_309 => GHC.Show.Show (Exceptions a_309)
  
  instance AST.Unmarshal.Unmarshal Exceptions
  
  instance Data.Foldable.Foldable Exceptions where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Exceptions where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Exceptions where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data For a = For
    { ann :: a,
      pattern :: (GHC.Base.NonEmpty (AST.Parse.Err ((Lhs GHC.Generics.:+: DestructuredLeftAssignment GHC.Generics.:+: RestAssignment) a))),
      body :: (AST.Parse.Err (Do a)),
      value :: (AST.Parse.Err (In a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_310.
        AST.Traversable1.Class.Traversable1 a_310
      )
  
  instance AST.Unmarshal.SymbolMatching For where
    matchedSymbols _ = [180]
    showFailure _ node_311 =
      "expected "
        GHC.Base.<> ( "for"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_311 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_311) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_312 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_313 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_314 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_315 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_312
          c1_313 = TreeSitter.Node.nodeStartPoint node_311
        TreeSitter.Node.TSPoint
          r2_314
          c2_315 = TreeSitter.Node.nodeEndPoint node_311
  
  deriving instance GHC.Classes.Eq a_316 => GHC.Classes.Eq (For a_316)
  
  deriving instance GHC.Classes.Ord a_317 => GHC.Classes.Ord (For a_317)
  
  deriving instance GHC.Show.Show a_318 => GHC.Show.Show (For a_318)
  
  instance AST.Unmarshal.Unmarshal For
  
  instance Data.Foldable.Foldable For where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor For where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable For where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Hash a = Hash
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((HashSplatArgument GHC.Generics.:+: Pair) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_319.
        AST.Traversable1.Class.Traversable1 a_319
      )
  
  instance AST.Unmarshal.SymbolMatching Hash where
    matchedSymbols _ = [250]
    showFailure _ node_320 =
      "expected "
        GHC.Base.<> ( "hash"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_320 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_320) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_321 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_322 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_323 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_324 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_321
          c1_322 = TreeSitter.Node.nodeStartPoint node_320
        TreeSitter.Node.TSPoint
          r2_323
          c2_324 = TreeSitter.Node.nodeEndPoint node_320
  
  deriving instance GHC.Classes.Eq a_325 => GHC.Classes.Eq (Hash a_325)
  
  deriving instance GHC.Classes.Ord a_326 => GHC.Classes.Ord (Hash a_326)
  
  deriving instance GHC.Show.Show a_327 => GHC.Show.Show (Hash a_327)
  
  instance AST.Unmarshal.Unmarshal Hash
  
  instance Data.Foldable.Foldable Hash where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Hash where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Hash where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HashSplatArgument a = HashSplatArgument
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_328.
        AST.Traversable1.Class.Traversable1 a_328
      )
  
  instance AST.Unmarshal.SymbolMatching HashSplatArgument where
    matchedSymbols _ = [211]
    showFailure _ node_329 =
      "expected "
        GHC.Base.<> ( "hash_splat_argument"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_329 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_329) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_330 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_331 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_332 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_333 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_330
          c1_331 = TreeSitter.Node.nodeStartPoint node_329
        TreeSitter.Node.TSPoint
          r2_332
          c2_333 = TreeSitter.Node.nodeEndPoint node_329
  
  deriving instance GHC.Classes.Eq a_334 => GHC.Classes.Eq (HashSplatArgument a_334)
  
  deriving instance GHC.Classes.Ord a_335 => GHC.Classes.Ord (HashSplatArgument a_335)
  
  deriving instance GHC.Show.Show a_336 => GHC.Show.Show (HashSplatArgument a_336)
  
  instance AST.Unmarshal.Unmarshal HashSplatArgument
  
  instance Data.Foldable.Foldable HashSplatArgument where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HashSplatArgument where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HashSplatArgument where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HashSplatParameter a = HashSplatParameter
    { ann :: a,
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_337.
        AST.Traversable1.Class.Traversable1 a_337
      )
  
  instance AST.Unmarshal.SymbolMatching HashSplatParameter where
    matchedSymbols _ = [155]
    showFailure _ node_338 =
      "expected "
        GHC.Base.<> ( "hash_splat_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_338 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_338) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_339 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_340 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_341 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_342 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_339
          c1_340 = TreeSitter.Node.nodeStartPoint node_338
        TreeSitter.Node.TSPoint
          r2_341
          c2_342 = TreeSitter.Node.nodeEndPoint node_338
  
  deriving instance GHC.Classes.Eq a_343 => GHC.Classes.Eq (HashSplatParameter a_343)
  
  deriving instance GHC.Classes.Ord a_344 => GHC.Classes.Ord (HashSplatParameter a_344)
  
  deriving instance GHC.Show.Show a_345 => GHC.Show.Show (HashSplatParameter a_345)
  
  instance AST.Unmarshal.Unmarshal HashSplatParameter
  
  instance Data.Foldable.Foldable HashSplatParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HashSplatParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HashSplatParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data If a = If
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err ((Else GHC.Generics.:+: Elsif) a))),
      consequence :: (GHC.Maybe.Maybe (AST.Parse.Err (Then a))),
      condition :: (AST.Parse.Err (Statement a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_346.
        AST.Traversable1.Class.Traversable1 a_346
      )
  
  instance AST.Unmarshal.SymbolMatching If where
    matchedSymbols _ = [186]
    showFailure _ node_347 =
      "expected "
        GHC.Base.<> ( "if"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_347 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_347) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_348 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_349 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_350 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_351 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_348
          c1_349 = TreeSitter.Node.nodeStartPoint node_347
        TreeSitter.Node.TSPoint
          r2_350
          c2_351 = TreeSitter.Node.nodeEndPoint node_347
  
  deriving instance GHC.Classes.Eq a_352 => GHC.Classes.Eq (If a_352)
  
  deriving instance GHC.Classes.Ord a_353 => GHC.Classes.Ord (If a_353)
  
  deriving instance GHC.Show.Show a_354 => GHC.Show.Show (If a_354)
  
  instance AST.Unmarshal.Unmarshal If
  
  instance Data.Foldable.Foldable If where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor If where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable If where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data IfModifier a = IfModifier
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_355.
        AST.Traversable1.Class.Traversable1 a_355
      )
  
  instance AST.Unmarshal.SymbolMatching IfModifier where
    matchedSymbols _ = [173]
    showFailure _ node_356 =
      "expected "
        GHC.Base.<> ( "if_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_356 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_356) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_357 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_358 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_359 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_360 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_357
          c1_358 = TreeSitter.Node.nodeStartPoint node_356
        TreeSitter.Node.TSPoint
          r2_359
          c2_360 = TreeSitter.Node.nodeEndPoint node_356
  
  deriving instance GHC.Classes.Eq a_361 => GHC.Classes.Eq (IfModifier a_361)
  
  deriving instance GHC.Classes.Ord a_362 => GHC.Classes.Ord (IfModifier a_362)
  
  deriving instance GHC.Show.Show a_363 => GHC.Show.Show (IfModifier a_363)
  
  instance AST.Unmarshal.Unmarshal IfModifier
  
  instance Data.Foldable.Foldable IfModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor IfModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable IfModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data In a = In {ann :: a, extraChildren :: (AST.Parse.Err (Arg a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_364.
        AST.Traversable1.Class.Traversable1 a_364
      )
  
  instance AST.Unmarshal.SymbolMatching In where
    matchedSymbols _ = [181]
    showFailure _ node_365 =
      "expected "
        GHC.Base.<> ( "in"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_365 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_365) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_366 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_367 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_368 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_369 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_366
          c1_367 = TreeSitter.Node.nodeStartPoint node_365
        TreeSitter.Node.TSPoint
          r2_368
          c2_369 = TreeSitter.Node.nodeEndPoint node_365
  
  deriving instance GHC.Classes.Eq a_370 => GHC.Classes.Eq (In a_370)
  
  deriving instance GHC.Classes.Ord a_371 => GHC.Classes.Ord (In a_371)
  
  deriving instance GHC.Show.Show a_372 => GHC.Show.Show (In a_372)
  
  instance AST.Unmarshal.Unmarshal In
  
  instance Data.Foldable.Foldable In where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor In where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable In where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Interpolation a = Interpolation
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Statement a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_373.
        AST.Traversable1.Class.Traversable1 a_373
      )
  
  instance AST.Unmarshal.SymbolMatching Interpolation where
    matchedSymbols _ = [240]
    showFailure _ node_374 =
      "expected "
        GHC.Base.<> ( "interpolation"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_374 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_374) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_375 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_376 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_377 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_378 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_375
          c1_376 = TreeSitter.Node.nodeStartPoint node_374
        TreeSitter.Node.TSPoint
          r2_377
          c2_378 = TreeSitter.Node.nodeEndPoint node_374
  
  deriving instance GHC.Classes.Eq a_379 => GHC.Classes.Eq (Interpolation a_379)
  
  deriving instance GHC.Classes.Ord a_380 => GHC.Classes.Ord (Interpolation a_380)
  
  deriving instance GHC.Show.Show a_381 => GHC.Show.Show (Interpolation a_381)
  
  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 KeywordParameter a = KeywordParameter
    { ann :: a,
      value :: (GHC.Maybe.Maybe (AST.Parse.Err (Arg a))),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_382.
        AST.Traversable1.Class.Traversable1 a_382
      )
  
  instance AST.Unmarshal.SymbolMatching KeywordParameter where
    matchedSymbols _ = [157]
    showFailure _ node_383 =
      "expected "
        GHC.Base.<> ( "keyword_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_383 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_383) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_384 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_385 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_386 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_387 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_384
          c1_385 = TreeSitter.Node.nodeStartPoint node_383
        TreeSitter.Node.TSPoint
          r2_386
          c2_387 = TreeSitter.Node.nodeEndPoint node_383
  
  deriving instance GHC.Classes.Eq a_388 => GHC.Classes.Eq (KeywordParameter a_388)
  
  deriving instance GHC.Classes.Ord a_389 => GHC.Classes.Ord (KeywordParameter a_389)
  
  deriving instance GHC.Show.Show a_390 => GHC.Show.Show (KeywordParameter a_390)
  
  instance AST.Unmarshal.Unmarshal KeywordParameter
  
  instance Data.Foldable.Foldable KeywordParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor KeywordParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable KeywordParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Lambda a = Lambda
    { ann :: a,
      body :: (AST.Parse.Err ((Block GHC.Generics.:+: DoBlock) a)),
      parameters :: (GHC.Maybe.Maybe (AST.Parse.Err (LambdaParameters a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_391.
        AST.Traversable1.Class.Traversable1 a_391
      )
  
  instance AST.Unmarshal.SymbolMatching Lambda where
    matchedSymbols _ = [252]
    showFailure _ node_392 =
      "expected "
        GHC.Base.<> ( "lambda"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_392 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_392) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_393 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_394 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_395 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_396 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_393
          c1_394 = TreeSitter.Node.nodeStartPoint node_392
        TreeSitter.Node.TSPoint
          r2_395
          c2_396 = TreeSitter.Node.nodeEndPoint node_392
  
  deriving instance GHC.Classes.Eq a_397 => GHC.Classes.Eq (Lambda a_397)
  
  deriving instance GHC.Classes.Ord a_398 => GHC.Classes.Ord (Lambda a_398)
  
  deriving instance GHC.Show.Show a_399 => GHC.Show.Show (Lambda a_399)
  
  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 :: ([AST.Parse.Err ((BlockParameter GHC.Generics.:+: DestructuredParameter GHC.Generics.:+: HashSplatParameter GHC.Generics.:+: Identifier GHC.Generics.:+: KeywordParameter GHC.Generics.:+: OptionalParameter GHC.Generics.:+: SplatParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_400.
        AST.Traversable1.Class.Traversable1 a_400
      )
  
  instance AST.Unmarshal.SymbolMatching LambdaParameters where
    matchedSymbols _ = [276]
    showFailure _ node_401 =
      "expected "
        GHC.Base.<> ( "lambda_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_401 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_401) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_402 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_403 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_404 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_405 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_402
          c1_403 = TreeSitter.Node.nodeStartPoint node_401
        TreeSitter.Node.TSPoint
          r2_404
          c2_405 = TreeSitter.Node.nodeEndPoint node_401
  
  deriving instance GHC.Classes.Eq a_406 => GHC.Classes.Eq (LambdaParameters a_406)
  
  deriving instance GHC.Classes.Ord a_407 => GHC.Classes.Ord (LambdaParameters a_407)
  
  deriving instance GHC.Show.Show a_408 => GHC.Show.Show (LambdaParameters a_408)
  
  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 LeftAssignmentList a = LeftAssignmentList
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Lhs GHC.Generics.:+: DestructuredLeftAssignment GHC.Generics.:+: RestAssignment) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_409.
        AST.Traversable1.Class.Traversable1 a_409
      )
  
  instance AST.Unmarshal.SymbolMatching LeftAssignmentList where
    matchedSymbols _ = [227]
    showFailure _ node_410 =
      "expected "
        GHC.Base.<> ( "left_assignment_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_410 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_410) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_411 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_412 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_413 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_414 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_411
          c1_412 = TreeSitter.Node.nodeStartPoint node_410
        TreeSitter.Node.TSPoint
          r2_413
          c2_414 = TreeSitter.Node.nodeEndPoint node_410
  
  deriving instance GHC.Classes.Eq a_415 => GHC.Classes.Eq (LeftAssignmentList a_415)
  
  deriving instance GHC.Classes.Ord a_416 => GHC.Classes.Ord (LeftAssignmentList a_416)
  
  deriving instance GHC.Show.Show a_417 => GHC.Show.Show (LeftAssignmentList a_417)
  
  instance AST.Unmarshal.Unmarshal LeftAssignmentList
  
  instance Data.Foldable.Foldable LeftAssignmentList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor LeftAssignmentList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable LeftAssignmentList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Method a = Method
    { ann :: a,
      name :: (AST.Parse.Err (MethodName a)),
      parameters :: (GHC.Maybe.Maybe (AST.Parse.Err (MethodParameters a))),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_418.
        AST.Traversable1.Class.Traversable1 a_418
      )
  
  instance AST.Unmarshal.SymbolMatching Method where
    matchedSymbols _ = [146]
    showFailure _ node_419 =
      "expected "
        GHC.Base.<> ( "method"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_419 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_419) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_420 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_421 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_422 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_423 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_420
          c1_421 = TreeSitter.Node.nodeStartPoint node_419
        TreeSitter.Node.TSPoint
          r2_422
          c2_423 = TreeSitter.Node.nodeEndPoint node_419
  
  deriving instance GHC.Classes.Eq a_424 => GHC.Classes.Eq (Method a_424)
  
  deriving instance GHC.Classes.Ord a_425 => GHC.Classes.Ord (Method a_425)
  
  deriving instance GHC.Show.Show a_426 => GHC.Show.Show (Method a_426)
  
  instance AST.Unmarshal.Unmarshal Method
  
  instance Data.Foldable.Foldable Method where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Method where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Method where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodCall a = MethodCall
    { ann :: a,
      arguments :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a))),
      block :: (GHC.Maybe.Maybe (AST.Parse.Err ((Block GHC.Generics.:+: DoBlock) a))),
      method :: (AST.Parse.Err ((Variable GHC.Generics.:+: Call GHC.Generics.:+: ScopeResolution) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_427.
        AST.Traversable1.Class.Traversable1 a_427
      )
  
  instance AST.Unmarshal.SymbolMatching MethodCall where
    matchedSymbols _ = [204, 205]
    showFailure _ node_428 =
      "expected "
        GHC.Base.<> ( "method_call, method_call"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_428 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_428) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_429 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_430 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_431 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_432 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_429
          c1_430 = TreeSitter.Node.nodeStartPoint node_428
        TreeSitter.Node.TSPoint
          r2_431
          c2_432 = TreeSitter.Node.nodeEndPoint node_428
  
  deriving instance GHC.Classes.Eq a_433 => GHC.Classes.Eq (MethodCall a_433)
  
  deriving instance GHC.Classes.Ord a_434 => GHC.Classes.Ord (MethodCall a_434)
  
  deriving instance GHC.Show.Show a_435 => GHC.Show.Show (MethodCall a_435)
  
  instance AST.Unmarshal.Unmarshal MethodCall
  
  instance Data.Foldable.Foldable MethodCall where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodCall where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodCall where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data MethodParameters a = MethodParameters
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((BlockParameter GHC.Generics.:+: DestructuredParameter GHC.Generics.:+: HashSplatParameter GHC.Generics.:+: Identifier GHC.Generics.:+: KeywordParameter GHC.Generics.:+: OptionalParameter GHC.Generics.:+: SplatParameter) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_436.
        AST.Traversable1.Class.Traversable1 a_436
      )
  
  instance AST.Unmarshal.SymbolMatching MethodParameters where
    matchedSymbols _ = [277]
    showFailure _ node_437 =
      "expected "
        GHC.Base.<> ( "method_parameters"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_437 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_437) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_438 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_439 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_440 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_441 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_438
          c1_439 = TreeSitter.Node.nodeStartPoint node_437
        TreeSitter.Node.TSPoint
          r2_440
          c2_441 = TreeSitter.Node.nodeEndPoint node_437
  
  deriving instance GHC.Classes.Eq a_442 => GHC.Classes.Eq (MethodParameters a_442)
  
  deriving instance GHC.Classes.Ord a_443 => GHC.Classes.Ord (MethodParameters a_443)
  
  deriving instance GHC.Show.Show a_444 => GHC.Show.Show (MethodParameters a_444)
  
  instance AST.Unmarshal.Unmarshal MethodParameters
  
  instance Data.Foldable.Foldable MethodParameters where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor MethodParameters where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable MethodParameters where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Module a = Module
    { ann :: a,
      name :: (AST.Parse.Err ((Constant GHC.Generics.:+: ScopeResolution) a)),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_445.
        AST.Traversable1.Class.Traversable1 a_445
      )
  
  instance AST.Unmarshal.SymbolMatching Module where
    matchedSymbols _ = [162]
    showFailure _ node_446 =
      "expected "
        GHC.Base.<> ( "module"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_446 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_446) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_447 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_448 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_449 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_450 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_447
          c1_448 = TreeSitter.Node.nodeStartPoint node_446
        TreeSitter.Node.TSPoint
          r2_449
          c2_450 = TreeSitter.Node.nodeEndPoint node_446
  
  deriving instance GHC.Classes.Eq a_451 => GHC.Classes.Eq (Module a_451)
  
  deriving instance GHC.Classes.Ord a_452 => GHC.Classes.Ord (Module a_452)
  
  deriving instance GHC.Show.Show a_453 => GHC.Show.Show (Module a_453)
  
  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 Next a = Next
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_454.
        AST.Traversable1.Class.Traversable1 a_454
      )
  
  instance AST.Unmarshal.SymbolMatching Next where
    matchedSymbols _ = [166, 170]
    showFailure _ node_455 =
      "expected "
        GHC.Base.<> ( "next, next"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_455 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_455) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_456 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_457 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_458 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_459 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_456
          c1_457 = TreeSitter.Node.nodeStartPoint node_455
        TreeSitter.Node.TSPoint
          r2_458
          c2_459 = TreeSitter.Node.nodeEndPoint node_455
  
  deriving instance GHC.Classes.Eq a_460 => GHC.Classes.Eq (Next a_460)
  
  deriving instance GHC.Classes.Ord a_461 => GHC.Classes.Ord (Next a_461)
  
  deriving instance GHC.Show.Show a_462 => GHC.Show.Show (Next a_462)
  
  instance AST.Unmarshal.Unmarshal Next
  
  instance Data.Foldable.Foldable Next where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Next where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Next where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Operator a = Operator {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_463.
        AST.Traversable1.Class.Traversable1 a_463
      )
  
  instance AST.Unmarshal.SymbolMatching Operator where
    matchedSymbols _ = [233]
    showFailure _ node_464 =
      "expected "
        GHC.Base.<> ( "operator"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_464 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_464) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_465 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_466 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_467 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_468 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_465
          c1_466 = TreeSitter.Node.nodeStartPoint node_464
        TreeSitter.Node.TSPoint
          r2_467
          c2_468 = TreeSitter.Node.nodeEndPoint node_464
  
  deriving instance GHC.Classes.Eq a_469 => GHC.Classes.Eq (Operator a_469)
  
  deriving instance GHC.Classes.Ord a_470 => GHC.Classes.Ord (Operator a_470)
  
  deriving instance GHC.Show.Show a_471 => GHC.Show.Show (Operator a_471)
  
  instance AST.Unmarshal.Unmarshal Operator
  
  instance Data.Foldable.Foldable Operator where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Operator where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Operator where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data OperatorAssignment a = OperatorAssignment
    { ann :: a,
      left :: (AST.Parse.Err (Lhs a)),
      right :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_472.
        AST.Traversable1.Class.Traversable1 a_472
      )
  
  instance AST.Unmarshal.SymbolMatching OperatorAssignment where
    matchedSymbols _ = [217, 218]
    showFailure _ node_473 =
      "expected "
        GHC.Base.<> ( "operator_assignment, operator_assignment"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_473 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_473) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_474 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_475 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_476 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_477 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_474
          c1_475 = TreeSitter.Node.nodeStartPoint node_473
        TreeSitter.Node.TSPoint
          r2_476
          c2_477 = TreeSitter.Node.nodeEndPoint node_473
  
  deriving instance GHC.Classes.Eq a_478 => GHC.Classes.Eq (OperatorAssignment a_478)
  
  deriving instance GHC.Classes.Ord a_479 => GHC.Classes.Ord (OperatorAssignment a_479)
  
  deriving instance GHC.Show.Show a_480 => GHC.Show.Show (OperatorAssignment a_480)
  
  instance AST.Unmarshal.Unmarshal OperatorAssignment
  
  instance Data.Foldable.Foldable OperatorAssignment where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OperatorAssignment where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OperatorAssignment where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data OptionalParameter a = OptionalParameter
    { ann :: a,
      value :: (AST.Parse.Err (Arg a)),
      name :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_481.
        AST.Traversable1.Class.Traversable1 a_481
      )
  
  instance AST.Unmarshal.SymbolMatching OptionalParameter where
    matchedSymbols _ = [158]
    showFailure _ node_482 =
      "expected "
        GHC.Base.<> ( "optional_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_482 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_482) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_483 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_484 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_485 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_486 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_483
          c1_484 = TreeSitter.Node.nodeStartPoint node_482
        TreeSitter.Node.TSPoint
          r2_485
          c2_486 = TreeSitter.Node.nodeEndPoint node_482
  
  deriving instance GHC.Classes.Eq a_487 => GHC.Classes.Eq (OptionalParameter a_487)
  
  deriving instance GHC.Classes.Ord a_488 => GHC.Classes.Ord (OptionalParameter a_488)
  
  deriving instance GHC.Show.Show a_489 => GHC.Show.Show (OptionalParameter a_489)
  
  instance AST.Unmarshal.Unmarshal OptionalParameter
  
  instance Data.Foldable.Foldable OptionalParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor OptionalParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable OptionalParameter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Pair a = Pair
    { ann :: a,
      value :: (AST.Parse.Err (Arg a)),
      key :: (AST.Parse.Err ((Arg GHC.Generics.:+: String GHC.Generics.:+: Symbol) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_490.
        AST.Traversable1.Class.Traversable1 a_490
      )
  
  instance AST.Unmarshal.SymbolMatching Pair where
    matchedSymbols _ = [251]
    showFailure _ node_491 =
      "expected "
        GHC.Base.<> ( "pair"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_491 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_491) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_492 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_493 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_494 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_495 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_492
          c1_493 = TreeSitter.Node.nodeStartPoint node_491
        TreeSitter.Node.TSPoint
          r2_494
          c2_495 = TreeSitter.Node.nodeEndPoint node_491
  
  deriving instance GHC.Classes.Eq a_496 => GHC.Classes.Eq (Pair a_496)
  
  deriving instance GHC.Classes.Ord a_497 => GHC.Classes.Ord (Pair a_497)
  
  deriving instance GHC.Show.Show a_498 => GHC.Show.Show (Pair a_498)
  
  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 ParenthesizedStatements a = ParenthesizedStatements
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_499.
        AST.Traversable1.Class.Traversable1 a_499
      )
  
  instance AST.Unmarshal.SymbolMatching ParenthesizedStatements where
    matchedSymbols _ = [200]
    showFailure _ node_500 =
      "expected "
        GHC.Base.<> ( "parenthesized_statements"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_500 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_500) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_501 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_502 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_503 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_504 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_501
          c1_502 = TreeSitter.Node.nodeStartPoint node_500
        TreeSitter.Node.TSPoint
          r2_503
          c2_504 = TreeSitter.Node.nodeEndPoint node_500
  
  deriving instance GHC.Classes.Eq a_505 => GHC.Classes.Eq (ParenthesizedStatements a_505)
  
  deriving instance GHC.Classes.Ord a_506 => GHC.Classes.Ord (ParenthesizedStatements a_506)
  
  deriving instance GHC.Show.Show a_507 => GHC.Show.Show (ParenthesizedStatements a_507)
  
  instance AST.Unmarshal.Unmarshal ParenthesizedStatements
  
  instance Data.Foldable.Foldable ParenthesizedStatements where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ParenthesizedStatements where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ParenthesizedStatements where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Pattern a = Pattern
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Arg GHC.Generics.:+: SplatArgument) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_508.
        AST.Traversable1.Class.Traversable1 a_508
      )
  
  instance AST.Unmarshal.SymbolMatching Pattern where
    matchedSymbols _ = [185]
    showFailure _ node_509 =
      "expected "
        GHC.Base.<> ( "pattern"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_509 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_509) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_510 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_511 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_512 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_513 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_510
          c1_511 = TreeSitter.Node.nodeStartPoint node_509
        TreeSitter.Node.TSPoint
          r2_512
          c2_513 = TreeSitter.Node.nodeEndPoint node_509
  
  deriving instance GHC.Classes.Eq a_514 => GHC.Classes.Eq (Pattern a_514)
  
  deriving instance GHC.Classes.Ord a_515 => GHC.Classes.Ord (Pattern a_515)
  
  deriving instance GHC.Show.Show a_516 => GHC.Show.Show (Pattern a_516)
  
  instance AST.Unmarshal.Unmarshal Pattern
  
  instance Data.Foldable.Foldable Pattern where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Pattern where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Pattern where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Program a = Program
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Uninterpreted) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_517.
        AST.Traversable1.Class.Traversable1 a_517
      )
  
  instance AST.Unmarshal.SymbolMatching Program where
    matchedSymbols _ = [141]
    showFailure _ node_518 =
      "expected "
        GHC.Base.<> ( "program"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_518 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_518) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_519 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_520 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_521 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_522 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_519
          c1_520 = TreeSitter.Node.nodeStartPoint node_518
        TreeSitter.Node.TSPoint
          r2_521
          c2_522 = TreeSitter.Node.nodeEndPoint node_518
  
  deriving instance GHC.Classes.Eq a_523 => GHC.Classes.Eq (Program a_523)
  
  deriving instance GHC.Classes.Ord a_524 => GHC.Classes.Ord (Program a_524)
  
  deriving instance GHC.Show.Show a_525 => GHC.Show.Show (Program a_525)
  
  instance AST.Unmarshal.Unmarshal Program
  
  instance Data.Foldable.Foldable Program where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Program where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Program where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Range a = Range
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Arg a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_526.
        AST.Traversable1.Class.Traversable1 a_526
      )
  
  instance AST.Unmarshal.SymbolMatching Range where
    matchedSymbols _ = [220]
    showFailure _ node_527 =
      "expected "
        GHC.Base.<> ( "range"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_527 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_527) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_528 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_529 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_530 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_531 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_528
          c1_529 = TreeSitter.Node.nodeStartPoint node_527
        TreeSitter.Node.TSPoint
          r2_530
          c2_531 = TreeSitter.Node.nodeEndPoint node_527
  
  deriving instance GHC.Classes.Eq a_532 => GHC.Classes.Eq (Range a_532)
  
  deriving instance GHC.Classes.Ord a_533 => GHC.Classes.Ord (Range a_533)
  
  deriving instance GHC.Show.Show a_534 => GHC.Show.Show (Range a_534)
  
  instance AST.Unmarshal.Unmarshal Range
  
  instance Data.Foldable.Foldable Range where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Range where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Range where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Rational a = Rational {ann :: a, extraChildren :: (AST.Parse.Err (Integer a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_535.
        AST.Traversable1.Class.Traversable1 a_535
      )
  
  instance AST.Unmarshal.SymbolMatching Rational where
    matchedSymbols _ = [238]
    showFailure _ node_536 =
      "expected "
        GHC.Base.<> ( "rational"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_536 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_536) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_537 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_538 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_539 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_540 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_537
          c1_538 = TreeSitter.Node.nodeStartPoint node_536
        TreeSitter.Node.TSPoint
          r2_539
          c2_540 = TreeSitter.Node.nodeEndPoint node_536
  
  deriving instance GHC.Classes.Eq a_541 => GHC.Classes.Eq (Rational a_541)
  
  deriving instance GHC.Classes.Ord a_542 => GHC.Classes.Ord (Rational a_542)
  
  deriving instance GHC.Show.Show a_543 => GHC.Show.Show (Rational a_543)
  
  instance AST.Unmarshal.Unmarshal Rational
  
  instance Data.Foldable.Foldable Rational where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Rational where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Rational where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Redo a = Redo
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_544.
        AST.Traversable1.Class.Traversable1 a_544
      )
  
  instance AST.Unmarshal.SymbolMatching Redo where
    matchedSymbols _ = [171]
    showFailure _ node_545 =
      "expected "
        GHC.Base.<> ( "redo"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_545 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_545) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_546 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_547 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_548 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_549 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_546
          c1_547 = TreeSitter.Node.nodeStartPoint node_545
        TreeSitter.Node.TSPoint
          r2_548
          c2_549 = TreeSitter.Node.nodeEndPoint node_545
  
  deriving instance GHC.Classes.Eq a_550 => GHC.Classes.Eq (Redo a_550)
  
  deriving instance GHC.Classes.Ord a_551 => GHC.Classes.Ord (Redo a_551)
  
  deriving instance GHC.Show.Show a_552 => GHC.Show.Show (Redo a_552)
  
  instance AST.Unmarshal.Unmarshal Redo
  
  instance Data.Foldable.Foldable Redo where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Redo where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Redo where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Regex a = Regex
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_553.
        AST.Traversable1.Class.Traversable1 a_553
      )
  
  instance AST.Unmarshal.SymbolMatching Regex where
    matchedSymbols _ = [246]
    showFailure _ node_554 =
      "expected "
        GHC.Base.<> ( "regex"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_554 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_554) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_555 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_556 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_557 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_558 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_555
          c1_556 = TreeSitter.Node.nodeStartPoint node_554
        TreeSitter.Node.TSPoint
          r2_557
          c2_558 = TreeSitter.Node.nodeEndPoint node_554
  
  deriving instance GHC.Classes.Eq a_559 => GHC.Classes.Eq (Regex a_559)
  
  deriving instance GHC.Classes.Ord a_560 => GHC.Classes.Ord (Regex a_560)
  
  deriving instance GHC.Show.Show a_561 => GHC.Show.Show (Regex a_561)
  
  instance AST.Unmarshal.Unmarshal Regex
  
  instance Data.Foldable.Foldable Regex where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Regex where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Regex where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Rescue a = Rescue
    { ann :: a,
      exceptions :: (GHC.Maybe.Maybe (AST.Parse.Err (Exceptions a))),
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (Then a))),
      variable :: (GHC.Maybe.Maybe (AST.Parse.Err (ExceptionVariable a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_562.
        AST.Traversable1.Class.Traversable1 a_562
      )
  
  instance AST.Unmarshal.SymbolMatching Rescue where
    matchedSymbols _ = [193]
    showFailure _ node_563 =
      "expected "
        GHC.Base.<> ( "rescue"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_563 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_563) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_564 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_565 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_566 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_567 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_564
          c1_565 = TreeSitter.Node.nodeStartPoint node_563
        TreeSitter.Node.TSPoint
          r2_566
          c2_567 = TreeSitter.Node.nodeEndPoint node_563
  
  deriving instance GHC.Classes.Eq a_568 => GHC.Classes.Eq (Rescue a_568)
  
  deriving instance GHC.Classes.Ord a_569 => GHC.Classes.Ord (Rescue a_569)
  
  deriving instance GHC.Show.Show a_570 => GHC.Show.Show (Rescue a_570)
  
  instance AST.Unmarshal.Unmarshal Rescue
  
  instance Data.Foldable.Foldable Rescue where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Rescue where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Rescue where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RescueModifier a = RescueModifier
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      handler :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_571.
        AST.Traversable1.Class.Traversable1 a_571
      )
  
  instance AST.Unmarshal.SymbolMatching RescueModifier where
    matchedSymbols _ = [177]
    showFailure _ node_572 =
      "expected "
        GHC.Base.<> ( "rescue_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_572 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_572) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_573 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_574 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_575 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_576 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_573
          c1_574 = TreeSitter.Node.nodeStartPoint node_572
        TreeSitter.Node.TSPoint
          r2_575
          c2_576 = TreeSitter.Node.nodeEndPoint node_572
  
  deriving instance GHC.Classes.Eq a_577 => GHC.Classes.Eq (RescueModifier a_577)
  
  deriving instance GHC.Classes.Ord a_578 => GHC.Classes.Ord (RescueModifier a_578)
  
  deriving instance GHC.Show.Show a_579 => GHC.Show.Show (RescueModifier a_579)
  
  instance AST.Unmarshal.Unmarshal RescueModifier
  
  instance Data.Foldable.Foldable RescueModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RescueModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RescueModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RestAssignment a = RestAssignment
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Lhs a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_580.
        AST.Traversable1.Class.Traversable1 a_580
      )
  
  instance AST.Unmarshal.SymbolMatching RestAssignment where
    matchedSymbols _ = [230]
    showFailure _ node_581 =
      "expected "
        GHC.Base.<> ( "rest_assignment"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_581 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_581) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_582 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_583 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_584 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_585 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_582
          c1_583 = TreeSitter.Node.nodeStartPoint node_581
        TreeSitter.Node.TSPoint
          r2_584
          c2_585 = TreeSitter.Node.nodeEndPoint node_581
  
  deriving instance GHC.Classes.Eq a_586 => GHC.Classes.Eq (RestAssignment a_586)
  
  deriving instance GHC.Classes.Ord a_587 => GHC.Classes.Ord (RestAssignment a_587)
  
  deriving instance GHC.Show.Show a_588 => GHC.Show.Show (RestAssignment a_588)
  
  instance AST.Unmarshal.Unmarshal RestAssignment
  
  instance Data.Foldable.Foldable RestAssignment where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RestAssignment where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RestAssignment where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Retry a = Retry
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_589.
        AST.Traversable1.Class.Traversable1 a_589
      )
  
  instance AST.Unmarshal.SymbolMatching Retry where
    matchedSymbols _ = [172]
    showFailure _ node_590 =
      "expected "
        GHC.Base.<> ( "retry"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_590 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_590) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_591 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_592 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_593 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_594 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_591
          c1_592 = TreeSitter.Node.nodeStartPoint node_590
        TreeSitter.Node.TSPoint
          r2_593
          c2_594 = TreeSitter.Node.nodeEndPoint node_590
  
  deriving instance GHC.Classes.Eq a_595 => GHC.Classes.Eq (Retry a_595)
  
  deriving instance GHC.Classes.Ord a_596 => GHC.Classes.Ord (Retry a_596)
  
  deriving instance GHC.Show.Show a_597 => GHC.Show.Show (Retry a_597)
  
  instance AST.Unmarshal.Unmarshal Retry
  
  instance Data.Foldable.Foldable Retry where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Retry where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Retry where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Return a = Return
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_598.
        AST.Traversable1.Class.Traversable1 a_598
      )
  
  instance AST.Unmarshal.SymbolMatching Return where
    matchedSymbols _ = [163, 167]
    showFailure _ node_599 =
      "expected "
        GHC.Base.<> ( "return, return"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_599 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_599) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_600 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_601 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_602 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_603 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_600
          c1_601 = TreeSitter.Node.nodeStartPoint node_599
        TreeSitter.Node.TSPoint
          r2_602
          c2_603 = TreeSitter.Node.nodeEndPoint node_599
  
  deriving instance GHC.Classes.Eq a_604 => GHC.Classes.Eq (Return a_604)
  
  deriving instance GHC.Classes.Ord a_605 => GHC.Classes.Ord (Return a_605)
  
  deriving instance GHC.Show.Show a_606 => GHC.Show.Show (Return a_606)
  
  instance AST.Unmarshal.Unmarshal Return
  
  instance Data.Foldable.Foldable Return where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Return where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Return where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data RightAssignmentList a = RightAssignmentList
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Arg GHC.Generics.:+: SplatArgument) a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_607.
        AST.Traversable1.Class.Traversable1 a_607
      )
  
  instance AST.Unmarshal.SymbolMatching RightAssignmentList where
    matchedSymbols _ = [226]
    showFailure _ node_608 =
      "expected "
        GHC.Base.<> ( "right_assignment_list"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_608 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_608) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_609 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_610 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_611 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_612 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_609
          c1_610 = TreeSitter.Node.nodeStartPoint node_608
        TreeSitter.Node.TSPoint
          r2_611
          c2_612 = TreeSitter.Node.nodeEndPoint node_608
  
  deriving instance GHC.Classes.Eq a_613 => GHC.Classes.Eq (RightAssignmentList a_613)
  
  deriving instance GHC.Classes.Ord a_614 => GHC.Classes.Ord (RightAssignmentList a_614)
  
  deriving instance GHC.Show.Show a_615 => GHC.Show.Show (RightAssignmentList a_615)
  
  instance AST.Unmarshal.Unmarshal RightAssignmentList
  
  instance Data.Foldable.Foldable RightAssignmentList where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor RightAssignmentList where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable RightAssignmentList where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data ScopeResolution a = ScopeResolution
    { ann :: a,
      name :: (AST.Parse.Err ((Constant GHC.Generics.:+: Identifier) a)),
      scope :: (GHC.Maybe.Maybe (AST.Parse.Err (Primary a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_616.
        AST.Traversable1.Class.Traversable1 a_616
      )
  
  instance AST.Unmarshal.SymbolMatching ScopeResolution where
    matchedSymbols _ = [202]
    showFailure _ node_617 =
      "expected "
        GHC.Base.<> ( "scope_resolution"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_617 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_617) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_618 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_619 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_620 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_621 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_618
          c1_619 = TreeSitter.Node.nodeStartPoint node_617
        TreeSitter.Node.TSPoint
          r2_620
          c2_621 = TreeSitter.Node.nodeEndPoint node_617
  
  deriving instance GHC.Classes.Eq a_622 => GHC.Classes.Eq (ScopeResolution a_622)
  
  deriving instance GHC.Classes.Ord a_623 => GHC.Classes.Ord (ScopeResolution a_623)
  
  deriving instance GHC.Show.Show a_624 => GHC.Show.Show (ScopeResolution a_624)
  
  instance AST.Unmarshal.Unmarshal ScopeResolution
  
  instance Data.Foldable.Foldable ScopeResolution where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ScopeResolution where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ScopeResolution where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Setter a = Setter
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Identifier a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_625.
        AST.Traversable1.Class.Traversable1 a_625
      )
  
  instance AST.Unmarshal.SymbolMatching Setter where
    matchedSymbols _ = [235]
    showFailure _ node_626 =
      "expected "
        GHC.Base.<> ( "setter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_626 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_626) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_627 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_628 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_629 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_630 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_627
          c1_628 = TreeSitter.Node.nodeStartPoint node_626
        TreeSitter.Node.TSPoint
          r2_629
          c2_630 = TreeSitter.Node.nodeEndPoint node_626
  
  deriving instance GHC.Classes.Eq a_631 => GHC.Classes.Eq (Setter a_631)
  
  deriving instance GHC.Classes.Ord a_632 => GHC.Classes.Ord (Setter a_632)
  
  deriving instance GHC.Show.Show a_633 => GHC.Show.Show (Setter a_633)
  
  instance AST.Unmarshal.Unmarshal Setter
  
  instance Data.Foldable.Foldable Setter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Setter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Setter where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SingletonClass a = SingletonClass
    { ann :: a,
      value :: (AST.Parse.Err (Arg a)),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_634.
        AST.Traversable1.Class.Traversable1 a_634
      )
  
  instance AST.Unmarshal.SymbolMatching SingletonClass where
    matchedSymbols _ = [161]
    showFailure _ node_635 =
      "expected "
        GHC.Base.<> ( "singleton_class"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_635 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_635) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_636 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_637 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_638 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_639 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_636
          c1_637 = TreeSitter.Node.nodeStartPoint node_635
        TreeSitter.Node.TSPoint
          r2_638
          c2_639 = TreeSitter.Node.nodeEndPoint node_635
  
  deriving instance GHC.Classes.Eq a_640 => GHC.Classes.Eq (SingletonClass a_640)
  
  deriving instance GHC.Classes.Ord a_641 => GHC.Classes.Ord (SingletonClass a_641)
  
  deriving instance GHC.Show.Show a_642 => GHC.Show.Show (SingletonClass a_642)
  
  instance AST.Unmarshal.Unmarshal SingletonClass
  
  instance Data.Foldable.Foldable SingletonClass where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SingletonClass where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SingletonClass where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SingletonMethod a = SingletonMethod
    { ann :: a,
      name :: (AST.Parse.Err (MethodName a)),
      parameters :: (GHC.Maybe.Maybe (AST.Parse.Err (MethodParameters a))),
      object :: (AST.Parse.Err ((Arg GHC.Generics.:+: Variable) a)),
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: Else GHC.Generics.:+: EmptyStatement GHC.Generics.:+: Ensure GHC.Generics.:+: Rescue) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_643.
        AST.Traversable1.Class.Traversable1 a_643
      )
  
  instance AST.Unmarshal.SymbolMatching SingletonMethod where
    matchedSymbols _ = [147]
    showFailure _ node_644 =
      "expected "
        GHC.Base.<> ( "singleton_method"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_644 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_644) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_645 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_646 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_647 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_648 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_645
          c1_646 = TreeSitter.Node.nodeStartPoint node_644
        TreeSitter.Node.TSPoint
          r2_647
          c2_648 = TreeSitter.Node.nodeEndPoint node_644
  
  deriving instance GHC.Classes.Eq a_649 => GHC.Classes.Eq (SingletonMethod a_649)
  
  deriving instance GHC.Classes.Ord a_650 => GHC.Classes.Ord (SingletonMethod a_650)
  
  deriving instance GHC.Show.Show a_651 => GHC.Show.Show (SingletonMethod a_651)
  
  instance AST.Unmarshal.Unmarshal SingletonMethod
  
  instance Data.Foldable.Foldable SingletonMethod where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SingletonMethod where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SingletonMethod where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SplatArgument a = SplatArgument
    { ann :: a,
      extraChildren :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_652.
        AST.Traversable1.Class.Traversable1 a_652
      )
  
  instance AST.Unmarshal.SymbolMatching SplatArgument where
    matchedSymbols _ = [210]
    showFailure _ node_653 =
      "expected "
        GHC.Base.<> ( "splat_argument"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_653 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_653) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_654 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_655 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_656 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_657 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_654
          c1_655 = TreeSitter.Node.nodeStartPoint node_653
        TreeSitter.Node.TSPoint
          r2_656
          c2_657 = TreeSitter.Node.nodeEndPoint node_653
  
  deriving instance GHC.Classes.Eq a_658 => GHC.Classes.Eq (SplatArgument a_658)
  
  deriving instance GHC.Classes.Ord a_659 => GHC.Classes.Ord (SplatArgument a_659)
  
  deriving instance GHC.Show.Show a_660 => GHC.Show.Show (SplatArgument a_660)
  
  instance AST.Unmarshal.Unmarshal SplatArgument
  
  instance Data.Foldable.Foldable SplatArgument where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SplatArgument where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SplatArgument where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SplatParameter a = SplatParameter
    { ann :: a,
      name :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_661.
        AST.Traversable1.Class.Traversable1 a_661
      )
  
  instance AST.Unmarshal.SymbolMatching SplatParameter where
    matchedSymbols _ = [154]
    showFailure _ node_662 =
      "expected "
        GHC.Base.<> ( "splat_parameter"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_662 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_662) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_663 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_664 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_665 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_666 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_663
          c1_664 = TreeSitter.Node.nodeStartPoint node_662
        TreeSitter.Node.TSPoint
          r2_665
          c2_666 = TreeSitter.Node.nodeEndPoint node_662
  
  deriving instance GHC.Classes.Eq a_667 => GHC.Classes.Eq (SplatParameter a_667)
  
  deriving instance GHC.Classes.Ord a_668 => GHC.Classes.Ord (SplatParameter a_668)
  
  deriving instance GHC.Show.Show a_669 => GHC.Show.Show (SplatParameter a_669)
  
  instance AST.Unmarshal.Unmarshal SplatParameter
  
  instance Data.Foldable.Foldable SplatParameter where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SplatParameter where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SplatParameter 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_670.
        AST.Traversable1.Class.Traversable1 a_670
      )
  
  instance AST.Unmarshal.SymbolMatching String where
    matchedSymbols _ = [241]
    showFailure _ node_671 =
      "expected "
        GHC.Base.<> ( "string"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_671 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_671) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_672 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_673 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_674 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_675 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_672
          c1_673 = TreeSitter.Node.nodeStartPoint node_671
        TreeSitter.Node.TSPoint
          r2_674
          c2_675 = TreeSitter.Node.nodeEndPoint node_671
  
  deriving instance GHC.Classes.Eq a_676 => GHC.Classes.Eq (String a_676)
  
  deriving instance GHC.Classes.Ord a_677 => GHC.Classes.Ord (String a_677)
  
  deriving instance GHC.Show.Show a_678 => GHC.Show.Show (String a_678)
  
  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 StringArray a = StringArray
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (BareString a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_679.
        AST.Traversable1.Class.Traversable1 a_679
      )
  
  instance AST.Unmarshal.SymbolMatching StringArray where
    matchedSymbols _ = [243]
    showFailure _ node_680 =
      "expected "
        GHC.Base.<> ( "string_array"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_680 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_680) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_681 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_682 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_683 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_684 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_681
          c1_682 = TreeSitter.Node.nodeStartPoint node_680
        TreeSitter.Node.TSPoint
          r2_683
          c2_684 = TreeSitter.Node.nodeEndPoint node_680
  
  deriving instance GHC.Classes.Eq a_685 => GHC.Classes.Eq (StringArray a_685)
  
  deriving instance GHC.Classes.Ord a_686 => GHC.Classes.Ord (StringArray a_686)
  
  deriving instance GHC.Show.Show a_687 => GHC.Show.Show (StringArray a_687)
  
  instance AST.Unmarshal.Unmarshal StringArray
  
  instance Data.Foldable.Foldable StringArray where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor StringArray where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable StringArray where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Subshell a = Subshell
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_688.
        AST.Traversable1.Class.Traversable1 a_688
      )
  
  instance AST.Unmarshal.SymbolMatching Subshell where
    matchedSymbols _ = [242]
    showFailure _ node_689 =
      "expected "
        GHC.Base.<> ( "subshell"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_689 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_689) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_690 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_691 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_692 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_693 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_690
          c1_691 = TreeSitter.Node.nodeStartPoint node_689
        TreeSitter.Node.TSPoint
          r2_692
          c2_693 = TreeSitter.Node.nodeEndPoint node_689
  
  deriving instance GHC.Classes.Eq a_694 => GHC.Classes.Eq (Subshell a_694)
  
  deriving instance GHC.Classes.Ord a_695 => GHC.Classes.Ord (Subshell a_695)
  
  deriving instance GHC.Show.Show a_696 => GHC.Show.Show (Subshell a_696)
  
  instance AST.Unmarshal.Unmarshal Subshell
  
  instance Data.Foldable.Foldable Subshell where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Subshell where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Subshell where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Superclass a = Superclass {ann :: a, extraChildren :: (AST.Parse.Err (Arg a))}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_697.
        AST.Traversable1.Class.Traversable1 a_697
      )
  
  instance AST.Unmarshal.SymbolMatching Superclass where
    matchedSymbols _ = [160]
    showFailure _ node_698 =
      "expected "
        GHC.Base.<> ( "superclass"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_698 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_698) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_699 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_700 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_701 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_702 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_699
          c1_700 = TreeSitter.Node.nodeStartPoint node_698
        TreeSitter.Node.TSPoint
          r2_701
          c2_702 = TreeSitter.Node.nodeEndPoint node_698
  
  deriving instance GHC.Classes.Eq a_703 => GHC.Classes.Eq (Superclass a_703)
  
  deriving instance GHC.Classes.Ord a_704 => GHC.Classes.Ord (Superclass a_704)
  
  deriving instance GHC.Show.Show a_705 => GHC.Show.Show (Superclass a_705)
  
  instance AST.Unmarshal.Unmarshal Superclass
  
  instance Data.Foldable.Foldable Superclass where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Superclass where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Superclass where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Symbol a = Symbol
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: Interpolation) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_706.
        AST.Traversable1.Class.Traversable1 a_706
      )
  
  instance AST.Unmarshal.SymbolMatching Symbol where
    matchedSymbols _ = [140, 245]
    showFailure _ node_707 =
      "expected "
        GHC.Base.<> ( "symbol, symbol"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_707 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_707) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_708 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_709 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_710 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_711 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_708
          c1_709 = TreeSitter.Node.nodeStartPoint node_707
        TreeSitter.Node.TSPoint
          r2_710
          c2_711 = TreeSitter.Node.nodeEndPoint node_707
  
  deriving instance GHC.Classes.Eq a_712 => GHC.Classes.Eq (Symbol a_712)
  
  deriving instance GHC.Classes.Ord a_713 => GHC.Classes.Ord (Symbol a_713)
  
  deriving instance GHC.Show.Show a_714 => GHC.Show.Show (Symbol a_714)
  
  instance AST.Unmarshal.Unmarshal Symbol
  
  instance Data.Foldable.Foldable Symbol where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Symbol where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Symbol where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data SymbolArray a = SymbolArray
    { ann :: a,
      extraChildren :: ([AST.Parse.Err (BareSymbol a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_715.
        AST.Traversable1.Class.Traversable1 a_715
      )
  
  instance AST.Unmarshal.SymbolMatching SymbolArray where
    matchedSymbols _ = [244]
    showFailure _ node_716 =
      "expected "
        GHC.Base.<> ( "symbol_array"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_716 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_716) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_717 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_718 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_719 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_720 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_717
          c1_718 = TreeSitter.Node.nodeStartPoint node_716
        TreeSitter.Node.TSPoint
          r2_719
          c2_720 = TreeSitter.Node.nodeEndPoint node_716
  
  deriving instance GHC.Classes.Eq a_721 => GHC.Classes.Eq (SymbolArray a_721)
  
  deriving instance GHC.Classes.Ord a_722 => GHC.Classes.Ord (SymbolArray a_722)
  
  deriving instance GHC.Show.Show a_723 => GHC.Show.Show (SymbolArray a_723)
  
  instance AST.Unmarshal.Unmarshal SymbolArray
  
  instance Data.Foldable.Foldable SymbolArray where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor SymbolArray where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable SymbolArray where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Then a = Then
    { ann :: a,
      extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: EmptyStatement) a)])
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_724.
        AST.Traversable1.Class.Traversable1 a_724
      )
  
  instance AST.Unmarshal.SymbolMatching Then where
    matchedSymbols _ = [190]
    showFailure _ node_725 =
      "expected "
        GHC.Base.<> ( "then"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_725 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_725) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_726 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_727 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_728 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_729 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_726
          c1_727 = TreeSitter.Node.nodeStartPoint node_725
        TreeSitter.Node.TSPoint
          r2_728
          c2_729 = TreeSitter.Node.nodeEndPoint node_725
  
  deriving instance GHC.Classes.Eq a_730 => GHC.Classes.Eq (Then a_730)
  
  deriving instance GHC.Classes.Ord a_731 => GHC.Classes.Ord (Then a_731)
  
  deriving instance GHC.Show.Show a_732 => GHC.Show.Show (Then a_732)
  
  instance AST.Unmarshal.Unmarshal Then
  
  instance Data.Foldable.Foldable Then where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Then where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Then where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Unary a = Unary
    { ann :: a,
      extraChildren :: (AST.Parse.Err ((Arg GHC.Generics.:+: Float GHC.Generics.:+: Integer GHC.Generics.:+: ParenthesizedStatements) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_733.
        AST.Traversable1.Class.Traversable1 a_733
      )
  
  instance AST.Unmarshal.SymbolMatching Unary where
    matchedSymbols _ = [223, 224, 225]
    showFailure _ node_734 =
      "expected "
        GHC.Base.<> ( "unary, unary, unary"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_734 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_734) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_735 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_736 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_737 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_738 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_735
          c1_736 = TreeSitter.Node.nodeStartPoint node_734
        TreeSitter.Node.TSPoint
          r2_737
          c2_738 = TreeSitter.Node.nodeEndPoint node_734
  
  deriving instance GHC.Classes.Eq a_739 => GHC.Classes.Eq (Unary a_739)
  
  deriving instance GHC.Classes.Ord a_740 => GHC.Classes.Ord (Unary a_740)
  
  deriving instance GHC.Show.Show a_741 => GHC.Show.Show (Unary a_741)
  
  instance AST.Unmarshal.Unmarshal Unary
  
  instance Data.Foldable.Foldable Unary where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Unary where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Unary where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Undef a = Undef
    { ann :: a,
      extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (MethodName a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_742.
        AST.Traversable1.Class.Traversable1 a_742
      )
  
  instance AST.Unmarshal.SymbolMatching Undef where
    matchedSymbols _ = [236]
    showFailure _ node_743 =
      "expected "
        GHC.Base.<> ( "undef"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_743 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_743) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_744 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_745 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_746 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_747 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_744
          c1_745 = TreeSitter.Node.nodeStartPoint node_743
        TreeSitter.Node.TSPoint
          r2_746
          c2_747 = TreeSitter.Node.nodeEndPoint node_743
  
  deriving instance GHC.Classes.Eq a_748 => GHC.Classes.Eq (Undef a_748)
  
  deriving instance GHC.Classes.Ord a_749 => GHC.Classes.Ord (Undef a_749)
  
  deriving instance GHC.Show.Show a_750 => GHC.Show.Show (Undef a_750)
  
  instance AST.Unmarshal.Unmarshal Undef
  
  instance Data.Foldable.Foldable Undef where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Undef where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Undef where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Unless a = Unless
    { ann :: a,
      alternative :: (GHC.Maybe.Maybe (AST.Parse.Err ((Else GHC.Generics.:+: Elsif) a))),
      consequence :: (GHC.Maybe.Maybe (AST.Parse.Err (Then a))),
      condition :: (AST.Parse.Err (Statement a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_751.
        AST.Traversable1.Class.Traversable1 a_751
      )
  
  instance AST.Unmarshal.SymbolMatching Unless where
    matchedSymbols _ = [187]
    showFailure _ node_752 =
      "expected "
        GHC.Base.<> ( "unless"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_752 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_752) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_753 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_754 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_755 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_756 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_753
          c1_754 = TreeSitter.Node.nodeStartPoint node_752
        TreeSitter.Node.TSPoint
          r2_755
          c2_756 = TreeSitter.Node.nodeEndPoint node_752
  
  deriving instance GHC.Classes.Eq a_757 => GHC.Classes.Eq (Unless a_757)
  
  deriving instance GHC.Classes.Ord a_758 => GHC.Classes.Ord (Unless a_758)
  
  deriving instance GHC.Show.Show a_759 => GHC.Show.Show (Unless a_759)
  
  instance AST.Unmarshal.Unmarshal Unless
  
  instance Data.Foldable.Foldable Unless where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Unless where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Unless where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UnlessModifier a = UnlessModifier
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_760.
        AST.Traversable1.Class.Traversable1 a_760
      )
  
  instance AST.Unmarshal.SymbolMatching UnlessModifier where
    matchedSymbols _ = [174]
    showFailure _ node_761 =
      "expected "
        GHC.Base.<> ( "unless_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_761 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_761) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_762 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_763 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_764 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_765 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_762
          c1_763 = TreeSitter.Node.nodeStartPoint node_761
        TreeSitter.Node.TSPoint
          r2_764
          c2_765 = TreeSitter.Node.nodeEndPoint node_761
  
  deriving instance GHC.Classes.Eq a_766 => GHC.Classes.Eq (UnlessModifier a_766)
  
  deriving instance GHC.Classes.Ord a_767 => GHC.Classes.Ord (UnlessModifier a_767)
  
  deriving instance GHC.Show.Show a_768 => GHC.Show.Show (UnlessModifier a_768)
  
  instance AST.Unmarshal.Unmarshal UnlessModifier
  
  instance Data.Foldable.Foldable UnlessModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UnlessModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UnlessModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Until a = Until
    { ann :: a,
      body :: (AST.Parse.Err (Do a)),
      condition :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_769.
        AST.Traversable1.Class.Traversable1 a_769
      )
  
  instance AST.Unmarshal.SymbolMatching Until where
    matchedSymbols _ = [179]
    showFailure _ node_770 =
      "expected "
        GHC.Base.<> ( "until"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_770 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_770) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_771 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_772 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_773 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_774 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_771
          c1_772 = TreeSitter.Node.nodeStartPoint node_770
        TreeSitter.Node.TSPoint
          r2_773
          c2_774 = TreeSitter.Node.nodeEndPoint node_770
  
  deriving instance GHC.Classes.Eq a_775 => GHC.Classes.Eq (Until a_775)
  
  deriving instance GHC.Classes.Ord a_776 => GHC.Classes.Ord (Until a_776)
  
  deriving instance GHC.Show.Show a_777 => GHC.Show.Show (Until a_777)
  
  instance AST.Unmarshal.Unmarshal Until
  
  instance Data.Foldable.Foldable Until where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Until where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Until where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data UntilModifier a = UntilModifier
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_778.
        AST.Traversable1.Class.Traversable1 a_778
      )
  
  instance AST.Unmarshal.SymbolMatching UntilModifier where
    matchedSymbols _ = [176]
    showFailure _ node_779 =
      "expected "
        GHC.Base.<> ( "until_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_779 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_779) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_780 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_781 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_782 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_783 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_780
          c1_781 = TreeSitter.Node.nodeStartPoint node_779
        TreeSitter.Node.TSPoint
          r2_782
          c2_783 = TreeSitter.Node.nodeEndPoint node_779
  
  deriving instance GHC.Classes.Eq a_784 => GHC.Classes.Eq (UntilModifier a_784)
  
  deriving instance GHC.Classes.Ord a_785 => GHC.Classes.Ord (UntilModifier a_785)
  
  deriving instance GHC.Show.Show a_786 => GHC.Show.Show (UntilModifier a_786)
  
  instance AST.Unmarshal.Unmarshal UntilModifier
  
  instance Data.Foldable.Foldable UntilModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor UntilModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable UntilModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data When a = When
    { ann :: a,
      pattern :: (GHC.Base.NonEmpty (AST.Parse.Err ((AnonymousComma GHC.Generics.:+: Pattern) a))),
      body :: (GHC.Maybe.Maybe (AST.Parse.Err (Then a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_787.
        AST.Traversable1.Class.Traversable1 a_787
      )
  
  instance AST.Unmarshal.SymbolMatching When where
    matchedSymbols _ = [184]
    showFailure _ node_788 =
      "expected "
        GHC.Base.<> ( "when"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_788 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_788) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_789 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_790 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_791 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_792 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_789
          c1_790 = TreeSitter.Node.nodeStartPoint node_788
        TreeSitter.Node.TSPoint
          r2_791
          c2_792 = TreeSitter.Node.nodeEndPoint node_788
  
  deriving instance GHC.Classes.Eq a_793 => GHC.Classes.Eq (When a_793)
  
  deriving instance GHC.Classes.Ord a_794 => GHC.Classes.Ord (When a_794)
  
  deriving instance GHC.Show.Show a_795 => GHC.Show.Show (When a_795)
  
  instance AST.Unmarshal.Unmarshal When
  
  instance Data.Foldable.Foldable When where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor When where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable When where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data While a = While
    { ann :: a,
      body :: (AST.Parse.Err (Do a)),
      condition :: (AST.Parse.Err (Arg a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_796.
        AST.Traversable1.Class.Traversable1 a_796
      )
  
  instance AST.Unmarshal.SymbolMatching While where
    matchedSymbols _ = [178]
    showFailure _ node_797 =
      "expected "
        GHC.Base.<> ( "while"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_797 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_797) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_798 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_799 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_800 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_801 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_798
          c1_799 = TreeSitter.Node.nodeStartPoint node_797
        TreeSitter.Node.TSPoint
          r2_800
          c2_801 = TreeSitter.Node.nodeEndPoint node_797
  
  deriving instance GHC.Classes.Eq a_802 => GHC.Classes.Eq (While a_802)
  
  deriving instance GHC.Classes.Ord a_803 => GHC.Classes.Ord (While a_803)
  
  deriving instance GHC.Show.Show a_804 => GHC.Show.Show (While a_804)
  
  instance AST.Unmarshal.Unmarshal While
  
  instance Data.Foldable.Foldable While where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor While where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable While where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data WhileModifier a = WhileModifier
    { ann :: a,
      body :: (AST.Parse.Err (Statement a)),
      condition :: (AST.Parse.Err ((Arg GHC.Generics.:+: Break GHC.Generics.:+: MethodCall GHC.Generics.:+: Next GHC.Generics.:+: Return GHC.Generics.:+: Yield) a))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_805.
        AST.Traversable1.Class.Traversable1 a_805
      )
  
  instance AST.Unmarshal.SymbolMatching WhileModifier where
    matchedSymbols _ = [175]
    showFailure _ node_806 =
      "expected "
        GHC.Base.<> ( "while_modifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_806 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_806) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_807 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_808 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_809 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_810 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_807
          c1_808 = TreeSitter.Node.nodeStartPoint node_806
        TreeSitter.Node.TSPoint
          r2_809
          c2_810 = TreeSitter.Node.nodeEndPoint node_806
  
  deriving instance GHC.Classes.Eq a_811 => GHC.Classes.Eq (WhileModifier a_811)
  
  deriving instance GHC.Classes.Ord a_812 => GHC.Classes.Ord (WhileModifier a_812)
  
  deriving instance GHC.Show.Show a_813 => GHC.Show.Show (WhileModifier a_813)
  
  instance AST.Unmarshal.Unmarshal WhileModifier
  
  instance Data.Foldable.Foldable WhileModifier where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor WhileModifier where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable WhileModifier where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Yield a = Yield
    { ann :: a,
      extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ArgumentList a)))
    }
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_814.
        AST.Traversable1.Class.Traversable1 a_814
      )
  
  instance AST.Unmarshal.SymbolMatching Yield where
    matchedSymbols _ = [164, 168]
    showFailure _ node_815 =
      "expected "
        GHC.Base.<> ( "yield, yield"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_815 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_815) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_816 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_817 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_818 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_819 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_816
          c1_817 = TreeSitter.Node.nodeStartPoint node_815
        TreeSitter.Node.TSPoint
          r2_818
          c2_819 = TreeSitter.Node.nodeEndPoint node_815
  
  deriving instance GHC.Classes.Eq a_820 => GHC.Classes.Eq (Yield a_820)
  
  deriving instance GHC.Classes.Ord a_821 => GHC.Classes.Ord (Yield a_821)
  
  deriving instance GHC.Show.Show a_822 => GHC.Show.Show (Yield a_822)
  
  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 AnonymousBang = AST.Token.Token "!" 90
  
  type AnonymousBangEqual = AST.Token.Token "!=" 83
  
  type AnonymousBangTilde = AST.Token.Token "!~" 87
  
  type AnonymousDQuote = AST.Token.Token "\"" 122
  
  type AnonymousHashLBrace = AST.Token.Token "#{" 115
  
  type AnonymousPercent = AST.Token.Token "%" 81
  
  type AnonymousPercentEqual = AST.Token.Token "%=" 61
  
  type AnonymousPercentiLParen = AST.Token.Token "%i(" 127
  
  type AnonymousPercentwLParen = AST.Token.Token "%w(" 126
  
  type AnonymousAmpersand = AST.Token.Token "&" 18
  
  type AnonymousAmpersandAmpersand = AST.Token.Token "&&" 72
  
  type AnonymousAmpersandAmpersandEqual = AST.Token.Token "&&=" 59
  
  type AnonymousAmpersandDot = AST.Token.Token "&." 50
  
  type AnonymousAmpersandEqual = AST.Token.Token "&=" 60
  
  type AnonymousLParen = AST.Token.Token "(" 9
  
  type AnonymousRParen = AST.Token.Token ")" 10
  
  type AnonymousStar = AST.Token.Token "*" 16
  
  type AnonymousStarStar = AST.Token.Token "**" 17
  
  type AnonymousStarStarEqual = AST.Token.Token "**=" 55
  
  type AnonymousStarEqual = AST.Token.Token "*=" 54
  
  type AnonymousPlus = AST.Token.Token "+" 79
  
  type AnonymousPlusEqual = AST.Token.Token "+=" 52
  
  type AnonymousPlusAt = AST.Token.Token "+@" 93
  
  type AnonymousComma = AST.Token.Token "," 13
  
  type AnonymousMinus = AST.Token.Token "-" 92
  
  type AnonymousMinusEqual = AST.Token.Token "-=" 53
  
  type AnonymousMinusRAngle = AST.Token.Token "->" 119
  
  type AnonymousMinusAt = AST.Token.Token "-@" 94
  
  type AnonymousDot = AST.Token.Token "." 11
  
  type AnonymousDotDot = AST.Token.Token ".." 67
  
  type AnonymousDotDotDot = AST.Token.Token "..." 68
  
  type AnonymousSlash = AST.Token.Token "/" 80
  
  type AnonymousSlashEqual = AST.Token.Token "/=" 56
  
  type AnonymousColon = AST.Token.Token ":" 19
  
  type AnonymousColonDQuote = AST.Token.Token ":\"" 123
  
  type AnonymousColonColon = AST.Token.Token "::" 12
  
  type AnonymousSemicolon = AST.Token.Token ";" 15
  
  type AnonymousLAngle = AST.Token.Token "<" 22
  
  type AnonymousLAngleLAngle = AST.Token.Token "<<" 73
  
  type AnonymousLAngleLAngleEqual = AST.Token.Token "<<=" 63
  
  type AnonymousLAngleEqual = AST.Token.Token "<=" 75
  
  type AnonymousLAngleEqualRAngle = AST.Token.Token "<=>" 85
  
  type AnonymousEqual = AST.Token.Token "=" 20
  
  type AnonymousEqualEqual = AST.Token.Token "==" 82
  
  type AnonymousEqualEqualEqual = AST.Token.Token "===" 84
  
  type AnonymousEqualRAngle = AST.Token.Token "=>" 46
  
  type AnonymousEqualTilde = AST.Token.Token "=~" 86
  
  type AnonymousRAngle = AST.Token.Token ">" 76
  
  type AnonymousRAngleEqual = AST.Token.Token ">=" 77
  
  type AnonymousRAngleRAngle = AST.Token.Token ">>" 74
  
  type AnonymousRAngleRAngleEqual = AST.Token.Token ">>=" 62
  
  type AnonymousQuestion = AST.Token.Token "?" 65
  
  type AnonymousBEGIN = AST.Token.Token "BEGIN" 4
  
  type AnonymousEND = AST.Token.Token "END" 7
  
  type AnonymousLBracket = AST.Token.Token "[" 47
  
  type AnonymousLBracketRBracket = AST.Token.Token "[]" 95
  
  type AnonymousLBracketRBracketEqual = AST.Token.Token "[]=" 96
  
  type AnonymousRBracket = AST.Token.Token "]" 48
  
  type AnonymousCaret = AST.Token.Token "^" 78
  
  type AnonymousCaretEqual = AST.Token.Token "^=" 64
  
  type AnonymousUnderscoreENDUnderscore = AST.Token.Token "__END__" 2
  
  type AnonymousBacktick = AST.Token.Token "`" 97
  
  type AnonymousAlias = AST.Token.Token "alias" 99
  
  type AnonymousAnd = AST.Token.Token "and" 69
  
  type AnonymousBegin = AST.Token.Token "begin" 44
  
  type AnonymousBreak = AST.Token.Token "break" 27
  
  type AnonymousCase = AST.Token.Token "case" 39
  
  data Character a = Character {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_823.
        AST.Traversable1.Class.Traversable1 a_823
      )
  
  instance AST.Unmarshal.SymbolMatching Character where
    matchedSymbols _ = [114]
    showFailure _ node_824 =
      "expected "
        GHC.Base.<> ( "character"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_824 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_824) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_825 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_826 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_827 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_828 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_825
          c1_826 = TreeSitter.Node.nodeStartPoint node_824
        TreeSitter.Node.TSPoint
          r2_827
          c2_828 = TreeSitter.Node.nodeEndPoint node_824
  
  deriving instance GHC.Classes.Eq a_829 => GHC.Classes.Eq (Character a_829)
  
  deriving instance GHC.Classes.Ord a_830 => GHC.Classes.Ord (Character a_830)
  
  deriving instance GHC.Show.Show a_831 => GHC.Show.Show (Character a_831)
  
  instance AST.Unmarshal.Unmarshal Character
  
  instance Data.Foldable.Foldable Character where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Character where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Character where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousClass = AST.Token.Token "class" 21
  
  data ClassVariable a = ClassVariable {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_832.
        AST.Traversable1.Class.Traversable1 a_832
      )
  
  instance AST.Unmarshal.SymbolMatching ClassVariable where
    matchedSymbols _ = [112]
    showFailure _ node_833 =
      "expected "
        GHC.Base.<> ( "class_variable"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_833 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_833) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_834 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_835 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_836 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_837 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_834
          c1_835 = TreeSitter.Node.nodeStartPoint node_833
        TreeSitter.Node.TSPoint
          r2_836
          c2_837 = TreeSitter.Node.nodeEndPoint node_833
  
  deriving instance GHC.Classes.Eq a_838 => GHC.Classes.Eq (ClassVariable a_838)
  
  deriving instance GHC.Classes.Ord a_839 => GHC.Classes.Ord (ClassVariable a_839)
  
  deriving instance GHC.Show.Show a_840 => GHC.Show.Show (ClassVariable a_840)
  
  instance AST.Unmarshal.Unmarshal ClassVariable
  
  instance Data.Foldable.Foldable ClassVariable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor ClassVariable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable ClassVariable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Complex a = Complex {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_841.
        AST.Traversable1.Class.Traversable1 a_841
      )
  
  instance AST.Unmarshal.SymbolMatching Complex where
    matchedSymbols _ = [103]
    showFailure _ node_842 =
      "expected "
        GHC.Base.<> ( "complex"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_842 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_842) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_843 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_844 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_845 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_846 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_843
          c1_844 = TreeSitter.Node.nodeStartPoint node_842
        TreeSitter.Node.TSPoint
          r2_845
          c2_846 = TreeSitter.Node.nodeEndPoint node_842
  
  deriving instance GHC.Classes.Eq a_847 => GHC.Classes.Eq (Complex a_847)
  
  deriving instance GHC.Classes.Ord a_848 => GHC.Classes.Ord (Complex a_848)
  
  deriving instance GHC.Show.Show a_849 => GHC.Show.Show (Complex a_849)
  
  instance AST.Unmarshal.Unmarshal Complex
  
  instance Data.Foldable.Foldable Complex where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Complex where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Complex where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Constant a = Constant {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_850.
        AST.Traversable1.Class.Traversable1 a_850
      )
  
  instance AST.Unmarshal.SymbolMatching Constant where
    matchedSymbols _ = [110]
    showFailure _ node_851 =
      "expected "
        GHC.Base.<> ( "constant"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_851 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_851) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_852 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_853 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_854 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_855 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_852
          c1_853 = TreeSitter.Node.nodeStartPoint node_851
        TreeSitter.Node.TSPoint
          r2_854
          c2_855 = TreeSitter.Node.nodeEndPoint node_851
  
  deriving instance GHC.Classes.Eq a_856 => GHC.Classes.Eq (Constant a_856)
  
  deriving instance GHC.Classes.Ord a_857 => GHC.Classes.Ord (Constant a_857)
  
  deriving instance GHC.Show.Show a_858 => GHC.Show.Show (Constant a_858)
  
  instance AST.Unmarshal.Unmarshal Constant
  
  instance Data.Foldable.Foldable Constant where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Constant where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Constant where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousDef = AST.Token.Token "def" 8
  
  type AnonymousDefinedQuestion = AST.Token.Token "defined?" 88
  
  type AnonymousDo = AST.Token.Token "do" 38
  
  type AnonymousElse = AST.Token.Token "else" 42
  
  type AnonymousElsif = AST.Token.Token "elsif" 41
  
  type AnonymousEnd = AST.Token.Token "end" 24
  
  type AnonymousEnsure = AST.Token.Token "ensure" 45
  
  data EscapeSequence a = EscapeSequence {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_859.
        AST.Traversable1.Class.Traversable1 a_859
      )
  
  instance AST.Unmarshal.SymbolMatching EscapeSequence where
    matchedSymbols _ = [117]
    showFailure _ node_860 =
      "expected "
        GHC.Base.<> ( "escape_sequence"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_860 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_860) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_861 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_862 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_863 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_864 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_861
          c1_862 = TreeSitter.Node.nodeStartPoint node_860
        TreeSitter.Node.TSPoint
          r2_863
          c2_864 = TreeSitter.Node.nodeEndPoint node_860
  
  deriving instance GHC.Classes.Eq a_865 => GHC.Classes.Eq (EscapeSequence a_865)
  
  deriving instance GHC.Classes.Ord a_866 => GHC.Classes.Ord (EscapeSequence a_866)
  
  deriving instance GHC.Show.Show a_867 => GHC.Show.Show (EscapeSequence a_867)
  
  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
  
  data False a = False {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_868.
        AST.Traversable1.Class.Traversable1 a_868
      )
  
  instance AST.Unmarshal.SymbolMatching False where
    matchedSymbols _ = [108]
    showFailure _ node_869 =
      "expected "
        GHC.Base.<> ( "false"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_869 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_869) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_870 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_871 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_872 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_873 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_870
          c1_871 = TreeSitter.Node.nodeStartPoint node_869
        TreeSitter.Node.TSPoint
          r2_872
          c2_873 = TreeSitter.Node.nodeEndPoint node_869
  
  deriving instance GHC.Classes.Eq a_874 => GHC.Classes.Eq (False a_874)
  
  deriving instance GHC.Classes.Ord a_875 => GHC.Classes.Ord (False a_875)
  
  deriving instance GHC.Show.Show a_876 => GHC.Show.Show (False a_876)
  
  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
  
  data Float a = Float {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_877.
        AST.Traversable1.Class.Traversable1 a_877
      )
  
  instance AST.Unmarshal.SymbolMatching Float where
    matchedSymbols _ = [102]
    showFailure _ node_878 =
      "expected "
        GHC.Base.<> ( "float"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_878 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_878) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_879 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_880 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_881 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_882 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_879
          c1_880 = TreeSitter.Node.nodeStartPoint node_878
        TreeSitter.Node.TSPoint
          r2_881
          c2_882 = TreeSitter.Node.nodeEndPoint node_878
  
  deriving instance GHC.Classes.Eq a_883 => GHC.Classes.Eq (Float a_883)
  
  deriving instance GHC.Classes.Ord a_884 => GHC.Classes.Ord (Float a_884)
  
  deriving instance GHC.Show.Show a_885 => GHC.Show.Show (Float a_885)
  
  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" 36
  
  data GlobalVariable a = GlobalVariable {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_886.
        AST.Traversable1.Class.Traversable1 a_886
      )
  
  instance AST.Unmarshal.SymbolMatching GlobalVariable where
    matchedSymbols _ = [113]
    showFailure _ node_887 =
      "expected "
        GHC.Base.<> ( "global_variable"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_887 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_887) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_888 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_889 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_890 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_891 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_888
          c1_889 = TreeSitter.Node.nodeStartPoint node_887
        TreeSitter.Node.TSPoint
          r2_890
          c2_891 = TreeSitter.Node.nodeEndPoint node_887
  
  deriving instance GHC.Classes.Eq a_892 => GHC.Classes.Eq (GlobalVariable a_892)
  
  deriving instance GHC.Classes.Ord a_893 => GHC.Classes.Ord (GlobalVariable a_893)
  
  deriving instance GHC.Show.Show a_894 => GHC.Show.Show (GlobalVariable a_894)
  
  instance AST.Unmarshal.Unmarshal GlobalVariable
  
  instance Data.Foldable.Foldable GlobalVariable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor GlobalVariable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable GlobalVariable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HeredocBeginning a = HeredocBeginning {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_895.
        AST.Traversable1.Class.Traversable1 a_895
      )
  
  instance AST.Unmarshal.SymbolMatching HeredocBeginning where
    matchedSymbols _ = [133]
    showFailure _ node_896 =
      "expected "
        GHC.Base.<> ( "heredoc_beginning"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_896 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_896) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_897 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_898 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_899 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_900 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_897
          c1_898 = TreeSitter.Node.nodeStartPoint node_896
        TreeSitter.Node.TSPoint
          r2_899
          c2_900 = TreeSitter.Node.nodeEndPoint node_896
  
  deriving instance GHC.Classes.Eq a_901 => GHC.Classes.Eq (HeredocBeginning a_901)
  
  deriving instance GHC.Classes.Ord a_902 => GHC.Classes.Ord (HeredocBeginning a_902)
  
  deriving instance GHC.Show.Show a_903 => GHC.Show.Show (HeredocBeginning a_903)
  
  instance AST.Unmarshal.Unmarshal HeredocBeginning
  
  instance Data.Foldable.Foldable HeredocBeginning where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HeredocBeginning where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HeredocBeginning where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data HeredocEnd a = HeredocEnd {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_904.
        AST.Traversable1.Class.Traversable1 a_904
      )
  
  instance AST.Unmarshal.SymbolMatching HeredocEnd where
    matchedSymbols _ = [132]
    showFailure _ node_905 =
      "expected "
        GHC.Base.<> ( "heredoc_end"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_905 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_905) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_906 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_907 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_908 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_909 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_906
          c1_907 = TreeSitter.Node.nodeStartPoint node_905
        TreeSitter.Node.TSPoint
          r2_908
          c2_909 = TreeSitter.Node.nodeEndPoint node_905
  
  deriving instance GHC.Classes.Eq a_910 => GHC.Classes.Eq (HeredocEnd a_910)
  
  deriving instance GHC.Classes.Ord a_911 => GHC.Classes.Ord (HeredocEnd a_911)
  
  deriving instance GHC.Show.Show a_912 => GHC.Show.Show (HeredocEnd a_912)
  
  instance AST.Unmarshal.Unmarshal HeredocEnd
  
  instance Data.Foldable.Foldable HeredocEnd where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor HeredocEnd where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable HeredocEnd where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Identifier a = Identifier {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_913.
        AST.Traversable1.Class.Traversable1 a_913
      )
  
  instance AST.Unmarshal.SymbolMatching Identifier where
    matchedSymbols _ = [1]
    showFailure _ node_914 =
      "expected "
        GHC.Base.<> ( "identifier"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_914 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_914) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_915 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_916 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_917 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_918 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_915
          c1_916 = TreeSitter.Node.nodeStartPoint node_914
        TreeSitter.Node.TSPoint
          r2_917
          c2_918 = TreeSitter.Node.nodeEndPoint node_914
  
  deriving instance GHC.Classes.Eq a_919 => GHC.Classes.Eq (Identifier a_919)
  
  deriving instance GHC.Classes.Ord a_920 => GHC.Classes.Ord (Identifier a_920)
  
  deriving instance GHC.Show.Show a_921 => GHC.Show.Show (Identifier a_921)
  
  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" 31
  
  type AnonymousIn = AST.Token.Token "in" 37
  
  data InstanceVariable a = InstanceVariable {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_922.
        AST.Traversable1.Class.Traversable1 a_922
      )
  
  instance AST.Unmarshal.SymbolMatching InstanceVariable where
    matchedSymbols _ = [111]
    showFailure _ node_923 =
      "expected "
        GHC.Base.<> ( "instance_variable"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_923 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_923) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_924 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_925 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_926 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_927 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_924
          c1_925 = TreeSitter.Node.nodeStartPoint node_923
        TreeSitter.Node.TSPoint
          r2_926
          c2_927 = TreeSitter.Node.nodeEndPoint node_923
  
  deriving instance GHC.Classes.Eq a_928 => GHC.Classes.Eq (InstanceVariable a_928)
  
  deriving instance GHC.Classes.Ord a_929 => GHC.Classes.Ord (InstanceVariable a_929)
  
  deriving instance GHC.Show.Show a_930 => GHC.Show.Show (InstanceVariable a_930)
  
  instance AST.Unmarshal.Unmarshal InstanceVariable
  
  instance Data.Foldable.Foldable InstanceVariable where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor InstanceVariable where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable InstanceVariable where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Integer a = Integer {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_931.
        AST.Traversable1.Class.Traversable1 a_931
      )
  
  instance AST.Unmarshal.SymbolMatching Integer where
    matchedSymbols _ = [101]
    showFailure _ node_932 =
      "expected "
        GHC.Base.<> ( "integer"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_932 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_932) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_933 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_934 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_935 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_936 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_933
          c1_934 = TreeSitter.Node.nodeStartPoint node_932
        TreeSitter.Node.TSPoint
          r2_935
          c2_936 = TreeSitter.Node.nodeEndPoint node_932
  
  deriving instance GHC.Classes.Eq a_937 => GHC.Classes.Eq (Integer a_937)
  
  deriving instance GHC.Classes.Ord a_938 => GHC.Classes.Ord (Integer a_938)
  
  deriving instance GHC.Show.Show a_939 => GHC.Show.Show (Integer a_939)
  
  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 AnonymousModule = AST.Token.Token "module" 23
  
  type AnonymousNext = AST.Token.Token "next" 28
  
  data Nil a = Nil {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_940.
        AST.Traversable1.Class.Traversable1 a_940
      )
  
  instance AST.Unmarshal.SymbolMatching Nil where
    matchedSymbols _ = [109]
    showFailure _ node_941 =
      "expected "
        GHC.Base.<> ( "nil"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_941 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_941) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_942 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_943 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_944 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_945 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_942
          c1_943 = TreeSitter.Node.nodeStartPoint node_941
        TreeSitter.Node.TSPoint
          r2_944
          c2_945 = TreeSitter.Node.nodeEndPoint node_941
  
  deriving instance GHC.Classes.Eq a_946 => GHC.Classes.Eq (Nil a_946)
  
  deriving instance GHC.Classes.Ord a_947 => GHC.Classes.Ord (Nil a_947)
  
  deriving instance GHC.Show.Show a_948 => GHC.Show.Show (Nil a_948)
  
  instance AST.Unmarshal.Unmarshal Nil
  
  instance Data.Foldable.Foldable Nil where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Nil where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Nil where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousNot = AST.Token.Token "not" 89
  
  type AnonymousOr = AST.Token.Token "or" 70
  
  type AnonymousR = AST.Token.Token "r" 104
  
  type AnonymousRedo = AST.Token.Token "redo" 29
  
  type AnonymousRescue = AST.Token.Token "rescue" 35
  
  type AnonymousRetry = AST.Token.Token "retry" 30
  
  type AnonymousReturn = AST.Token.Token "return" 25
  
  data Self a = Self {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_949.
        AST.Traversable1.Class.Traversable1 a_949
      )
  
  instance AST.Unmarshal.SymbolMatching Self where
    matchedSymbols _ = [106]
    showFailure _ node_950 =
      "expected "
        GHC.Base.<> ( "self"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_950 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_950) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_951 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_952 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_953 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_954 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_951
          c1_952 = TreeSitter.Node.nodeStartPoint node_950
        TreeSitter.Node.TSPoint
          r2_953
          c2_954 = TreeSitter.Node.nodeEndPoint node_950
  
  deriving instance GHC.Classes.Eq a_955 => GHC.Classes.Eq (Self a_955)
  
  deriving instance GHC.Classes.Ord a_956 => GHC.Classes.Ord (Self a_956)
  
  deriving instance GHC.Show.Show a_957 => GHC.Show.Show (Self a_957)
  
  instance AST.Unmarshal.Unmarshal Self
  
  instance Data.Foldable.Foldable Self where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Self where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Self where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  data Super a = Super {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_958.
        AST.Traversable1.Class.Traversable1 a_958
      )
  
  instance AST.Unmarshal.SymbolMatching Super where
    matchedSymbols _ = [105]
    showFailure _ node_959 =
      "expected "
        GHC.Base.<> ( "super"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_959 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_959) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_960 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_961 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_962 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_963 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_960
          c1_961 = TreeSitter.Node.nodeStartPoint node_959
        TreeSitter.Node.TSPoint
          r2_962
          c2_963 = TreeSitter.Node.nodeEndPoint node_959
  
  deriving instance GHC.Classes.Eq a_964 => GHC.Classes.Eq (Super a_964)
  
  deriving instance GHC.Classes.Ord a_965 => GHC.Classes.Ord (Super a_965)
  
  deriving instance GHC.Show.Show a_966 => GHC.Show.Show (Super a_966)
  
  instance AST.Unmarshal.Unmarshal Super
  
  instance Data.Foldable.Foldable Super where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Super where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Super where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousThen = AST.Token.Token "then" 43
  
  data True a = True {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_967.
        AST.Traversable1.Class.Traversable1 a_967
      )
  
  instance AST.Unmarshal.SymbolMatching True where
    matchedSymbols _ = [107]
    showFailure _ node_968 =
      "expected "
        GHC.Base.<> ( "true"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_968 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_968) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_969 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_970 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_971 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_972 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_969
          c1_970 = TreeSitter.Node.nodeStartPoint node_968
        TreeSitter.Node.TSPoint
          r2_971
          c2_972 = TreeSitter.Node.nodeEndPoint node_968
  
  deriving instance GHC.Classes.Eq a_973 => GHC.Classes.Eq (True a_973)
  
  deriving instance GHC.Classes.Ord a_974 => GHC.Classes.Ord (True a_974)
  
  deriving instance GHC.Show.Show a_975 => GHC.Show.Show (True a_975)
  
  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 AnonymousUndef = AST.Token.Token "undef" 98
  
  data Uninterpreted a = Uninterpreted {ann :: a, text :: Data.Text.Internal.Text}
    deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
    deriving anyclass
      ( forall a_976.
        AST.Traversable1.Class.Traversable1 a_976
      )
  
  instance AST.Unmarshal.SymbolMatching Uninterpreted where
    matchedSymbols _ = [3]
    showFailure _ node_977 =
      "expected "
        GHC.Base.<> ( "uninterpreted"
                        GHC.Base.<> ( " but got "
                                        GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_977 GHC.Classes.== 65535
                                                        then "ERROR"
                                                        else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_977) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_978 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_979 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_980 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_981 GHC.Base.<> "]")))))))))
                                                    )
                                    )
                    )
      where
        TreeSitter.Node.TSPoint
          r1_978
          c1_979 = TreeSitter.Node.nodeStartPoint node_977
        TreeSitter.Node.TSPoint
          r2_980
          c2_981 = TreeSitter.Node.nodeEndPoint node_977
  
  deriving instance GHC.Classes.Eq a_982 => GHC.Classes.Eq (Uninterpreted a_982)
  
  deriving instance GHC.Classes.Ord a_983 => GHC.Classes.Ord (Uninterpreted a_983)
  
  deriving instance GHC.Show.Show a_984 => GHC.Show.Show (Uninterpreted a_984)
  
  instance AST.Unmarshal.Unmarshal Uninterpreted
  
  instance Data.Foldable.Foldable Uninterpreted where
    foldMap = AST.Traversable1.Class.foldMapDefault1
  
  instance GHC.Base.Functor Uninterpreted where
    fmap = AST.Traversable1.Class.fmapDefault1
  
  instance Data.Traversable.Traversable Uninterpreted where
    traverse = AST.Traversable1.Class.traverseDefault1
  
  type AnonymousUnless = AST.Token.Token "unless" 32
  
  type AnonymousUntil = AST.Token.Token "until" 34
  
  type AnonymousWhen = AST.Token.Token "when" 40
  
  type AnonymousWhile = AST.Token.Token "while" 33
  
  type AnonymousYield = AST.Token.Token "yield" 26
  
  type AnonymousLBrace = AST.Token.Token "{" 5
  
  type AnonymousPipe = AST.Token.Token "|" 14
  
  type AnonymousPipeEqual = AST.Token.Token "|=" 58
  
  type AnonymousPipePipe = AST.Token.Token "||" 71
  
  type AnonymousPipePipeEqual = AST.Token.Token "||=" 57
  
  type AnonymousRBrace = AST.Token.Token "}" 6
  
  type AnonymousTilde = AST.Token.Token "~" 91
  