@ ProgramNode (location: (0...3743))
├── locals: [:bar, :baz, :qux, :b, :a]
└── statements:
    @ StatementsNode (location: (0...3743))
    └── body: (length: 170)
        ├── @ MatchRequiredNode (location: (0...10))
        │   ├── value:
        │   │   @ CallNode (location: (0...3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (0...3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (7...10))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (4...6) = "=>"
        ├── @ MatchRequiredNode (location: (11...19))
        │   ├── value:
        │   │   @ CallNode (location: (11...14))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (11...14) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ IntegerNode (location: (18...19))
        │   │   └── flags: decimal
        │   └── operator_loc: (15...17) = "=>"
        ├── @ MatchRequiredNode (location: (20...30))
        │   ├── value:
        │   │   @ CallNode (location: (20...23))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (20...23) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FloatNode (location: (27...30))
        │   └── operator_loc: (24...26) = "=>"
        ├── @ MatchRequiredNode (location: (31...40))
        │   ├── value:
        │   │   @ CallNode (location: (31...34))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (31...34) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (38...40))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (38...39))
        │   │       └── flags: decimal
        │   └── operator_loc: (35...37) = "=>"
        ├── @ MatchRequiredNode (location: (41...50))
        │   ├── value:
        │   │   @ CallNode (location: (41...44))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (41...44) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RationalNode (location: (48...50))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (48...49))
        │   │       └── flags: decimal
        │   └── operator_loc: (45...47) = "=>"
        ├── @ MatchRequiredNode (location: (51...62))
        │   ├── value:
        │   │   @ CallNode (location: (51...54))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (51...54) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (58...62))
        │   │   ├── opening_loc: (58...59) = ":"
        │   │   ├── value_loc: (59...62) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (55...57) = "=>"
        ├── @ MatchRequiredNode (location: (63...77))
        │   ├── value:
        │   │   @ CallNode (location: (63...66))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (63...66) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (70...77))
        │   │   ├── opening_loc: (70...73) = "%s["
        │   │   ├── value_loc: (73...76) = "foo"
        │   │   ├── closing_loc: (76...77) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (67...69) = "=>"
        ├── @ MatchRequiredNode (location: (78...91))
        │   ├── value:
        │   │   @ CallNode (location: (78...81))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (78...81) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (85...91))
        │   │   ├── opening_loc: (85...87) = ":\""
        │   │   ├── value_loc: (87...90) = "foo"
        │   │   ├── closing_loc: (90...91) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (82...84) = "=>"
        ├── @ MatchRequiredNode (location: (92...104))
        │   ├── value:
        │   │   @ CallNode (location: (92...95))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (92...95) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (99...104))
        │   │   ├── opening_loc: (99...100) = "/"
        │   │   ├── content_loc: (100...103) = "foo"
        │   │   ├── closing_loc: (103...104) = "/"
        │   │   ├── unescaped: "foo"
        │   │   └── flags: ∅
        │   └── operator_loc: (96...98) = "=>"
        ├── @ MatchRequiredNode (location: (105...117))
        │   ├── value:
        │   │   @ CallNode (location: (105...108))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (105...108) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ XStringNode (location: (112...117))
        │   │   ├── opening_loc: (112...113) = "`"
        │   │   ├── content_loc: (113...116) = "foo"
        │   │   ├── closing_loc: (116...117) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (109...111) = "=>"
        ├── @ MatchRequiredNode (location: (118...132))
        │   ├── value:
        │   │   @ CallNode (location: (118...121))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (118...121) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ XStringNode (location: (125...132))
        │   │   ├── opening_loc: (125...128) = "%x["
        │   │   ├── content_loc: (128...131) = "foo"
        │   │   ├── closing_loc: (131...132) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (122...124) = "=>"
        ├── @ MatchRequiredNode (location: (133...147))
        │   ├── value:
        │   │   @ CallNode (location: (133...136))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (133...136) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (140...147))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (143...146))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (143...146) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (140...143) = "%i["
        │   │   └── closing_loc: (146...147) = "]"
        │   └── operator_loc: (137...139) = "=>"
        ├── @ MatchRequiredNode (location: (148...162))
        │   ├── value:
        │   │   @ CallNode (location: (148...151))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (148...151) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (155...162))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (158...161))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (158...161) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (155...158) = "%I["
        │   │   └── closing_loc: (161...162) = "]"
        │   └── operator_loc: (152...154) = "=>"
        ├── @ MatchRequiredNode (location: (163...177))
        │   ├── value:
        │   │   @ CallNode (location: (163...166))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (163...166) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (170...177))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (173...176))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (173...176) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (170...173) = "%w["
        │   │   └── closing_loc: (176...177) = "]"
        │   └── operator_loc: (167...169) = "=>"
        ├── @ MatchRequiredNode (location: (178...192))
        │   ├── value:
        │   │   @ CallNode (location: (178...181))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (178...181) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (185...192))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (188...191))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (188...191) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (185...188) = "%W["
        │   │   └── closing_loc: (191...192) = "]"
        │   └── operator_loc: (182...184) = "=>"
        ├── @ MatchRequiredNode (location: (193...207))
        │   ├── value:
        │   │   @ CallNode (location: (193...196))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (193...196) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (200...207))
        │   │   ├── opening_loc: (200...203) = "%q["
        │   │   ├── content_loc: (203...206) = "foo"
        │   │   ├── closing_loc: (206...207) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (197...199) = "=>"
        ├── @ MatchRequiredNode (location: (208...222))
        │   ├── value:
        │   │   @ CallNode (location: (208...211))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (208...211) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (215...222))
        │   │   ├── opening_loc: (215...218) = "%Q["
        │   │   ├── content_loc: (218...221) = "foo"
        │   │   ├── closing_loc: (221...222) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (212...214) = "=>"
        ├── @ MatchRequiredNode (location: (223...235))
        │   ├── value:
        │   │   @ CallNode (location: (223...226))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (223...226) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (230...235))
        │   │   ├── opening_loc: (230...231) = "\""
        │   │   ├── content_loc: (231...234) = "foo"
        │   │   ├── closing_loc: (234...235) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (227...229) = "=>"
        ├── @ MatchRequiredNode (location: (236...246))
        │   ├── value:
        │   │   @ CallNode (location: (236...239))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (236...239) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ NilNode (location: (243...246))
        │   └── operator_loc: (240...242) = "=>"
        ├── @ MatchRequiredNode (location: (247...258))
        │   ├── value:
        │   │   @ CallNode (location: (247...250))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (247...250) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SelfNode (location: (254...258))
        │   └── operator_loc: (251...253) = "=>"
        ├── @ MatchRequiredNode (location: (259...270))
        │   ├── value:
        │   │   @ CallNode (location: (259...262))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (259...262) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ TrueNode (location: (266...270))
        │   └── operator_loc: (263...265) = "=>"
        ├── @ MatchRequiredNode (location: (271...283))
        │   ├── value:
        │   │   @ CallNode (location: (271...274))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (271...274) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FalseNode (location: (278...283))
        │   └── operator_loc: (275...277) = "=>"
        ├── @ MatchRequiredNode (location: (284...299))
        │   ├── value:
        │   │   @ CallNode (location: (284...287))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (284...287) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (291...299))
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (288...290) = "=>"
        ├── @ MatchRequiredNode (location: (300...315))
        │   ├── value:
        │   │   @ CallNode (location: (300...303))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (300...303) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (307...315))
        │   └── operator_loc: (304...306) = "=>"
        ├── @ MatchRequiredNode (location: (316...335))
        │   ├── value:
        │   │   @ CallNode (location: (316...319))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (316...319) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (323...335))
        │   └── operator_loc: (320...322) = "=>"
        ├── @ MatchRequiredNode (location: (336...353))
        │   ├── value:
        │   │   @ CallNode (location: (336...339))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (336...339) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ LambdaNode (location: (343...353))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (343...345) = "->"
        │   │   ├── opening_loc: (346...347) = "{"
        │   │   ├── closing_loc: (352...353) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (348...351))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (348...351))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (340...342) = "=>"
        ├── @ MatchRequiredNode (location: (355...368))
        │   ├── value:
        │   │   @ CallNode (location: (355...358))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (355...358) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (362...368))
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (362...363))
        │   │   │   └── flags: decimal
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (367...368))
        │   │   │   └── flags: decimal
        │   │   ├── operator_loc: (364...366) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (359...361) = "=>"
        ├── @ MatchRequiredNode (location: (369...386))
        │   ├── value:
        │   │   @ CallNode (location: (369...372))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (369...372) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (376...386))
        │   │   ├── left:
        │   │   │   @ FloatNode (location: (376...379))
        │   │   ├── right:
        │   │   │   @ FloatNode (location: (383...386))
        │   │   ├── operator_loc: (380...382) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (373...375) = "=>"
        ├── @ MatchRequiredNode (location: (387...402))
        │   ├── value:
        │   │   @ CallNode (location: (387...390))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (387...390) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (394...402))
        │   │   ├── left:
        │   │   │   @ ImaginaryNode (location: (394...396))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (394...395))
        │   │   │       └── flags: decimal
        │   │   ├── right:
        │   │   │   @ ImaginaryNode (location: (400...402))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (400...401))
        │   │   │       └── flags: decimal
        │   │   ├── operator_loc: (397...399) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (391...393) = "=>"
        ├── @ MatchRequiredNode (location: (403...418))
        │   ├── value:
        │   │   @ CallNode (location: (403...406))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (403...406) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (410...418))
        │   │   ├── left:
        │   │   │   @ RationalNode (location: (410...412))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (410...411))
        │   │   │       └── flags: decimal
        │   │   ├── right:
        │   │   │   @ RationalNode (location: (416...418))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (416...417))
        │   │   │       └── flags: decimal
        │   │   ├── operator_loc: (413...415) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (407...409) = "=>"
        ├── @ MatchRequiredNode (location: (419...438))
        │   ├── value:
        │   │   @ CallNode (location: (419...422))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (419...422) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (426...438))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (426...430))
        │   │   │   ├── opening_loc: (426...427) = ":"
        │   │   │   ├── value_loc: (427...430) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (434...438))
        │   │   │   ├── opening_loc: (434...435) = ":"
        │   │   │   ├── value_loc: (435...438) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (431...433) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (423...425) = "=>"
        ├── @ MatchRequiredNode (location: (439...464))
        │   ├── value:
        │   │   @ CallNode (location: (439...442))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (439...442) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (446...464))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (446...453))
        │   │   │   ├── opening_loc: (446...449) = "%s["
        │   │   │   ├── value_loc: (449...452) = "foo"
        │   │   │   ├── closing_loc: (452...453) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (457...464))
        │   │   │   ├── opening_loc: (457...460) = "%s["
        │   │   │   ├── value_loc: (460...463) = "foo"
        │   │   │   ├── closing_loc: (463...464) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (454...456) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (443...445) = "=>"
        ├── @ MatchRequiredNode (location: (465...488))
        │   ├── value:
        │   │   @ CallNode (location: (465...468))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (465...468) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (472...488))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (472...478))
        │   │   │   ├── opening_loc: (472...474) = ":\""
        │   │   │   ├── value_loc: (474...477) = "foo"
        │   │   │   ├── closing_loc: (477...478) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (482...488))
        │   │   │   ├── opening_loc: (482...484) = ":\""
        │   │   │   ├── value_loc: (484...487) = "foo"
        │   │   │   ├── closing_loc: (487...488) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (479...481) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (469...471) = "=>"
        ├── @ MatchRequiredNode (location: (489...510))
        │   ├── value:
        │   │   @ CallNode (location: (489...492))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (489...492) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (496...510))
        │   │   ├── left:
        │   │   │   @ RegularExpressionNode (location: (496...501))
        │   │   │   ├── opening_loc: (496...497) = "/"
        │   │   │   ├── content_loc: (497...500) = "foo"
        │   │   │   ├── closing_loc: (500...501) = "/"
        │   │   │   ├── unescaped: "foo"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ RegularExpressionNode (location: (505...510))
        │   │   │   ├── opening_loc: (505...506) = "/"
        │   │   │   ├── content_loc: (506...509) = "foo"
        │   │   │   ├── closing_loc: (509...510) = "/"
        │   │   │   ├── unescaped: "foo"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (502...504) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (493...495) = "=>"
        ├── @ MatchRequiredNode (location: (511...532))
        │   ├── value:
        │   │   @ CallNode (location: (511...514))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (511...514) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (518...532))
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (518...523))
        │   │   │   ├── opening_loc: (518...519) = "`"
        │   │   │   ├── content_loc: (519...522) = "foo"
        │   │   │   ├── closing_loc: (522...523) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (527...532))
        │   │   │   ├── opening_loc: (527...528) = "`"
        │   │   │   ├── content_loc: (528...531) = "foo"
        │   │   │   ├── closing_loc: (531...532) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (524...526) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (515...517) = "=>"
        ├── @ MatchRequiredNode (location: (533...558))
        │   ├── value:
        │   │   @ CallNode (location: (533...536))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (533...536) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (540...558))
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (540...547))
        │   │   │   ├── opening_loc: (540...543) = "%x["
        │   │   │   ├── content_loc: (543...546) = "foo"
        │   │   │   ├── closing_loc: (546...547) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (551...558))
        │   │   │   ├── opening_loc: (551...554) = "%x["
        │   │   │   ├── content_loc: (554...557) = "foo"
        │   │   │   ├── closing_loc: (557...558) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (548...550) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (537...539) = "=>"
        ├── @ MatchRequiredNode (location: (559...584))
        │   ├── value:
        │   │   @ CallNode (location: (559...562))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (559...562) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (566...584))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (566...573))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (569...572))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (569...572) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (566...569) = "%i["
        │   │   │   └── closing_loc: (572...573) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (577...584))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (580...583))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (580...583) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (577...580) = "%i["
        │   │   │   └── closing_loc: (583...584) = "]"
        │   │   ├── operator_loc: (574...576) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (563...565) = "=>"
        ├── @ MatchRequiredNode (location: (585...610))
        │   ├── value:
        │   │   @ CallNode (location: (585...588))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (585...588) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (592...610))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (592...599))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (595...598))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (595...598) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (592...595) = "%I["
        │   │   │   └── closing_loc: (598...599) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (603...610))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (606...609))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (606...609) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (603...606) = "%I["
        │   │   │   └── closing_loc: (609...610) = "]"
        │   │   ├── operator_loc: (600...602) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (589...591) = "=>"
        ├── @ MatchRequiredNode (location: (611...636))
        │   ├── value:
        │   │   @ CallNode (location: (611...614))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (611...614) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (618...636))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (618...625))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (621...624))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (621...624) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (618...621) = "%w["
        │   │   │   └── closing_loc: (624...625) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (629...636))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (632...635))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (632...635) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (629...632) = "%w["
        │   │   │   └── closing_loc: (635...636) = "]"
        │   │   ├── operator_loc: (626...628) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (615...617) = "=>"
        ├── @ MatchRequiredNode (location: (637...662))
        │   ├── value:
        │   │   @ CallNode (location: (637...640))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (637...640) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (644...662))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (644...651))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (647...650))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (647...650) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (644...647) = "%W["
        │   │   │   └── closing_loc: (650...651) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (655...662))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (658...661))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (658...661) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (655...658) = "%W["
        │   │   │   └── closing_loc: (661...662) = "]"
        │   │   ├── operator_loc: (652...654) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (641...643) = "=>"
        ├── @ MatchRequiredNode (location: (663...688))
        │   ├── value:
        │   │   @ CallNode (location: (663...666))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (663...666) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (670...688))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (670...677))
        │   │   │   ├── opening_loc: (670...673) = "%q["
        │   │   │   ├── content_loc: (673...676) = "foo"
        │   │   │   ├── closing_loc: (676...677) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (681...688))
        │   │   │   ├── opening_loc: (681...684) = "%q["
        │   │   │   ├── content_loc: (684...687) = "foo"
        │   │   │   ├── closing_loc: (687...688) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (678...680) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (667...669) = "=>"
        ├── @ MatchRequiredNode (location: (689...714))
        │   ├── value:
        │   │   @ CallNode (location: (689...692))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (689...692) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (696...714))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (696...703))
        │   │   │   ├── opening_loc: (696...699) = "%Q["
        │   │   │   ├── content_loc: (699...702) = "foo"
        │   │   │   ├── closing_loc: (702...703) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (707...714))
        │   │   │   ├── opening_loc: (707...710) = "%Q["
        │   │   │   ├── content_loc: (710...713) = "foo"
        │   │   │   ├── closing_loc: (713...714) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (704...706) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (693...695) = "=>"
        ├── @ MatchRequiredNode (location: (715...736))
        │   ├── value:
        │   │   @ CallNode (location: (715...718))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (715...718) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (722...736))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (722...727))
        │   │   │   ├── opening_loc: (722...723) = "\""
        │   │   │   ├── content_loc: (723...726) = "foo"
        │   │   │   ├── closing_loc: (726...727) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (731...736))
        │   │   │   ├── opening_loc: (731...732) = "\""
        │   │   │   ├── content_loc: (732...735) = "foo"
        │   │   │   ├── closing_loc: (735...736) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (728...730) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (719...721) = "=>"
        ├── @ MatchRequiredNode (location: (737...754))
        │   ├── value:
        │   │   @ CallNode (location: (737...740))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (737...740) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (744...754))
        │   │   ├── left:
        │   │   │   @ NilNode (location: (744...747))
        │   │   ├── right:
        │   │   │   @ NilNode (location: (751...754))
        │   │   ├── operator_loc: (748...750) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (741...743) = "=>"
        ├── @ MatchRequiredNode (location: (755...774))
        │   ├── value:
        │   │   @ CallNode (location: (755...758))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (755...758) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (762...774))
        │   │   ├── left:
        │   │   │   @ SelfNode (location: (762...766))
        │   │   ├── right:
        │   │   │   @ SelfNode (location: (770...774))
        │   │   ├── operator_loc: (767...769) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (759...761) = "=>"
        ├── @ MatchRequiredNode (location: (775...794))
        │   ├── value:
        │   │   @ CallNode (location: (775...778))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (775...778) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (782...794))
        │   │   ├── left:
        │   │   │   @ TrueNode (location: (782...786))
        │   │   ├── right:
        │   │   │   @ TrueNode (location: (790...794))
        │   │   ├── operator_loc: (787...789) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (779...781) = "=>"
        ├── @ MatchRequiredNode (location: (795...816))
        │   ├── value:
        │   │   @ CallNode (location: (795...798))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (795...798) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (802...816))
        │   │   ├── left:
        │   │   │   @ FalseNode (location: (802...807))
        │   │   ├── right:
        │   │   │   @ FalseNode (location: (811...816))
        │   │   ├── operator_loc: (808...810) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (799...801) = "=>"
        ├── @ MatchRequiredNode (location: (817...844))
        │   ├── value:
        │   │   @ CallNode (location: (817...820))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (817...820) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (824...844))
        │   │   ├── left:
        │   │   │   @ SourceFileNode (location: (824...832))
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── right:
        │   │   │   @ SourceFileNode (location: (836...844))
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── operator_loc: (833...835) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (821...823) = "=>"
        ├── @ MatchRequiredNode (location: (845...872))
        │   ├── value:
        │   │   @ CallNode (location: (845...848))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (845...848) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (852...872))
        │   │   ├── left:
        │   │   │   @ SourceLineNode (location: (852...860))
        │   │   ├── right:
        │   │   │   @ SourceLineNode (location: (864...872))
        │   │   ├── operator_loc: (861...863) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (849...851) = "=>"
        ├── @ MatchRequiredNode (location: (873...908))
        │   ├── value:
        │   │   @ CallNode (location: (873...876))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (873...876) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (880...908))
        │   │   ├── left:
        │   │   │   @ SourceEncodingNode (location: (880...892))
        │   │   ├── right:
        │   │   │   @ SourceEncodingNode (location: (896...908))
        │   │   ├── operator_loc: (893...895) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (877...879) = "=>"
        ├── @ MatchRequiredNode (location: (909...940))
        │   ├── value:
        │   │   @ CallNode (location: (909...912))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (909...912) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RangeNode (location: (916...940))
        │   │   ├── left:
        │   │   │   @ LambdaNode (location: (916...926))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (916...918) = "->"
        │   │   │   ├── opening_loc: (919...920) = "{"
        │   │   │   ├── closing_loc: (925...926) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (921...924))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (921...924))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── right:
        │   │   │   @ LambdaNode (location: (930...940))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (930...932) = "->"
        │   │   │   ├── opening_loc: (933...934) = "{"
        │   │   │   ├── closing_loc: (939...940) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (935...938))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (935...938))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── operator_loc: (927...929) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (913...915) = "=>"
        ├── @ MatchRequiredNode (location: (942...953))
        │   ├── value:
        │   │   @ CallNode (location: (942...945))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (942...945) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (949...953))
        │   │   ├── variable:
        │   │   │   @ LocalVariableReadNode (location: (950...953))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (949...950) = "^"
        │   └── operator_loc: (946...948) = "=>"
        ├── @ MatchRequiredNode (location: (954...966))
        │   ├── value:
        │   │   @ CallNode (location: (954...957))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (954...957) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (961...966))
        │   │   ├── variable:
        │   │   │   @ InstanceVariableReadNode (location: (962...966))
        │   │   │   └── name: :@bar
        │   │   └── operator_loc: (961...962) = "^"
        │   └── operator_loc: (958...960) = "=>"
        ├── @ MatchRequiredNode (location: (967...980))
        │   ├── value:
        │   │   @ CallNode (location: (967...970))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (967...970) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (974...980))
        │   │   ├── variable:
        │   │   │   @ ClassVariableReadNode (location: (975...980))
        │   │   │   └── name: :@@bar
        │   │   └── operator_loc: (974...975) = "^"
        │   └── operator_loc: (971...973) = "=>"
        ├── @ MatchRequiredNode (location: (981...993))
        │   ├── value:
        │   │   @ CallNode (location: (981...984))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (981...984) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (988...993))
        │   │   ├── variable:
        │   │   │   @ GlobalVariableReadNode (location: (989...993))
        │   │   │   └── name: :$bar
        │   │   └── operator_loc: (988...989) = "^"
        │   └── operator_loc: (985...987) = "=>"
        ├── @ MatchRequiredNode (location: (995...1006))
        │   ├── value:
        │   │   @ CallNode (location: (995...998))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (995...998) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (1002...1006))
        │   │   ├── expression:
        │   │   │   @ IntegerNode (location: (1004...1005))
        │   │   │   └── flags: decimal
        │   │   ├── operator_loc: (1002...1003) = "^"
        │   │   ├── lparen_loc: (1003...1004) = "("
        │   │   └── rparen_loc: (1005...1006) = ")"
        │   └── operator_loc: (999...1001) = "=>"
        ├── @ MatchRequiredNode (location: (1007...1020))
        │   ├── value:
        │   │   @ CallNode (location: (1007...1010))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1007...1010) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (1014...1020))
        │   │   ├── expression:
        │   │   │   @ NilNode (location: (1016...1019))
        │   │   ├── operator_loc: (1014...1015) = "^"
        │   │   ├── lparen_loc: (1015...1016) = "("
        │   │   └── rparen_loc: (1019...1020) = ")"
        │   └── operator_loc: (1011...1013) = "=>"
        ├── @ MatchRequiredNode (location: (1021...1044))
        │   ├── value:
        │   │   @ CallNode (location: (1021...1024))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1021...1024) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (1028...1044))
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (1030...1043))
        │   │   │   ├── receiver:
        │   │   │   │   @ StringNode (location: (1030...1035))
        │   │   │   │   ├── opening_loc: (1030...1031) = "\""
        │   │   │   │   ├── content_loc: (1031...1034) = "bar"
        │   │   │   │   ├── closing_loc: (1034...1035) = "\""
        │   │   │   │   └── unescaped: "bar"
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (1036...1037) = "+"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (1038...1043))
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ StringNode (location: (1038...1043))
        │   │   │   │           ├── opening_loc: (1038...1039) = "\""
        │   │   │   │           ├── content_loc: (1039...1042) = "baz"
        │   │   │   │           ├── closing_loc: (1042...1043) = "\""
        │   │   │   │           └── unescaped: "baz"
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: ∅
        │   │   │   └── name: "+"
        │   │   ├── operator_loc: (1028...1029) = "^"
        │   │   ├── lparen_loc: (1029...1030) = "("
        │   │   └── rparen_loc: (1043...1044) = ")"
        │   └── operator_loc: (1025...1027) = "=>"
        ├── @ MatchRequiredNode (location: (1046...1056))
        │   ├── value:
        │   │   @ CallNode (location: (1046...1049))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1046...1049) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ConstantReadNode (location: (1053...1056))
        │   │   └── name: :Foo
        │   └── operator_loc: (1050...1052) = "=>"
        ├── @ MatchRequiredNode (location: (1057...1077))
        │   ├── value:
        │   │   @ CallNode (location: (1057...1060))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1057...1060) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (1064...1077))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (1064...1072))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (1064...1067))
        │   │   │   │   └── name: :Foo
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (1069...1072))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (1067...1069) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (1074...1077))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (1072...1074) = "::"
        │   └── operator_loc: (1061...1063) = "=>"
        ├── @ MatchRequiredNode (location: (1078...1090))
        │   ├── value:
        │   │   @ CallNode (location: (1078...1081))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1078...1081) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (1085...1090))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (1087...1090))
        │   │   │   └── name: :Foo
        │   │   └── delimiter_loc: (1085...1087) = "::"
        │   └── operator_loc: (1082...1084) = "=>"
        ├── @ MatchRequiredNode (location: (1091...1113))
        │   ├── value:
        │   │   @ CallNode (location: (1091...1094))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1091...1094) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (1098...1113))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (1098...1108))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantPathNode (location: (1098...1103))
        │   │   │   │   ├── parent: ∅
        │   │   │   │   ├── child:
        │   │   │   │   │   @ ConstantReadNode (location: (1100...1103))
        │   │   │   │   │   └── name: :Foo
        │   │   │   │   └── delimiter_loc: (1098...1100) = "::"
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (1105...1108))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (1103...1105) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (1110...1113))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (1108...1110) = "::"
        │   └── operator_loc: (1095...1097) = "=>"
        ├── @ MatchRequiredNode (location: (1115...1127))
        │   ├── value:
        │   │   @ CallNode (location: (1115...1118))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1115...1118) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1122...1127))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1122...1125))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1125...1126) = "("
        │   │   └── closing_loc: (1126...1127) = ")"
        │   └── operator_loc: (1119...1121) = "=>"
        ├── @ MatchRequiredNode (location: (1128...1141))
        │   ├── value:
        │   │   @ CallNode (location: (1128...1131))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1128...1131) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1135...1141))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1135...1138))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (1139...1140))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1138...1139) = "("
        │   │   └── closing_loc: (1140...1141) = ")"
        │   └── operator_loc: (1132...1134) = "=>"
        ├── @ MatchRequiredNode (location: (1142...1161))
        │   ├── value:
        │   │   @ CallNode (location: (1142...1145))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1142...1145) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1149...1161))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1149...1152))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (1153...1154))
        │   │   │   │   └── flags: decimal
        │   │   │   ├── @ IntegerNode (location: (1156...1157))
        │   │   │   │   └── flags: decimal
        │   │   │   └── @ IntegerNode (location: (1159...1160))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1152...1153) = "("
        │   │   └── closing_loc: (1160...1161) = ")"
        │   └── operator_loc: (1146...1148) = "=>"
        ├── @ MatchRequiredNode (location: (1162...1177))
        │   ├── value:
        │   │   @ CallNode (location: (1162...1165))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1162...1165) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1169...1177))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1169...1172))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1173...1176))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1172...1173) = "("
        │   │   └── closing_loc: (1176...1177) = ")"
        │   └── operator_loc: (1166...1168) = "=>"
        ├── @ MatchRequiredNode (location: (1178...1199))
        │   ├── value:
        │   │   @ CallNode (location: (1178...1181))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1178...1181) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1185...1199))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1185...1188))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1189...1193))
        │   │   │   ├── operator_loc: (1189...1190) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1190...1193))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1195...1198))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1188...1189) = "("
        │   │   └── closing_loc: (1198...1199) = ")"
        │   └── operator_loc: (1182...1184) = "=>"
        ├── @ MatchRequiredNode (location: (1200...1221))
        │   ├── value:
        │   │   @ CallNode (location: (1200...1203))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1200...1203) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1207...1221))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1207...1210))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1211...1214))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1216...1220))
        │   │   │   ├── operator_loc: (1216...1217) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1217...1220))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1210...1211) = "("
        │   │   └── closing_loc: (1220...1221) = ")"
        │   └── operator_loc: (1204...1206) = "=>"
        ├── @ MatchRequiredNode (location: (1222...1249))
        │   ├── value:
        │   │   @ CallNode (location: (1222...1225))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1222...1225) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (1229...1249))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1229...1232))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (1233...1237))
        │   │   │   ├── operator_loc: (1233...1234) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1234...1237))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1239...1242))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (1244...1248))
        │   │   │   ├── operator_loc: (1244...1245) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1245...1248))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1232...1233) = "("
        │   │   └── closing_loc: (1248...1249) = ")"
        │   └── operator_loc: (1226...1228) = "=>"
        ├── @ MatchRequiredNode (location: (1251...1263))
        │   ├── value:
        │   │   @ CallNode (location: (1251...1254))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1251...1254) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1258...1263))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1258...1261))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1261...1262) = "["
        │   │   └── closing_loc: (1262...1263) = "]"
        │   └── operator_loc: (1255...1257) = "=>"
        ├── @ MatchRequiredNode (location: (1264...1277))
        │   ├── value:
        │   │   @ CallNode (location: (1264...1267))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1264...1267) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1271...1277))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1271...1274))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (1275...1276))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1274...1275) = "["
        │   │   └── closing_loc: (1276...1277) = "]"
        │   └── operator_loc: (1268...1270) = "=>"
        ├── @ MatchRequiredNode (location: (1278...1297))
        │   ├── value:
        │   │   @ CallNode (location: (1278...1281))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1278...1281) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1285...1297))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1285...1288))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (1289...1290))
        │   │   │   │   └── flags: decimal
        │   │   │   ├── @ IntegerNode (location: (1292...1293))
        │   │   │   │   └── flags: decimal
        │   │   │   └── @ IntegerNode (location: (1295...1296))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1288...1289) = "["
        │   │   └── closing_loc: (1296...1297) = "]"
        │   └── operator_loc: (1282...1284) = "=>"
        ├── @ MatchRequiredNode (location: (1298...1315))
        │   ├── value:
        │   │   @ CallNode (location: (1298...1301))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1298...1301) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1305...1315))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1305...1308))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (1309...1314))
        │   │   │       ├── constant:
        │   │   │       │   @ ConstantReadNode (location: (1309...1312))
        │   │   │       │   └── name: :Foo
        │   │   │       ├── requireds: (length: 0)
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (1312...1313) = "["
        │   │   │       └── closing_loc: (1313...1314) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1308...1309) = "["
        │   │   └── closing_loc: (1314...1315) = "]"
        │   └── operator_loc: (1302...1304) = "=>"
        ├── @ MatchRequiredNode (location: (1316...1331))
        │   ├── value:
        │   │   @ CallNode (location: (1316...1319))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1316...1319) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1323...1331))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1323...1326))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1327...1330))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1326...1327) = "["
        │   │   └── closing_loc: (1330...1331) = "]"
        │   └── operator_loc: (1320...1322) = "=>"
        ├── @ MatchRequiredNode (location: (1332...1353))
        │   ├── value:
        │   │   @ CallNode (location: (1332...1335))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1332...1335) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1339...1353))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1339...1342))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1343...1347))
        │   │   │   ├── operator_loc: (1343...1344) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1344...1347))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1349...1352))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1342...1343) = "["
        │   │   └── closing_loc: (1352...1353) = "]"
        │   └── operator_loc: (1336...1338) = "=>"
        ├── @ MatchRequiredNode (location: (1354...1375))
        │   ├── value:
        │   │   @ CallNode (location: (1354...1357))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1354...1357) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1361...1375))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1361...1364))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1365...1368))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1370...1374))
        │   │   │   ├── operator_loc: (1370...1371) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1371...1374))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1364...1365) = "["
        │   │   └── closing_loc: (1374...1375) = "]"
        │   └── operator_loc: (1358...1360) = "=>"
        ├── @ MatchRequiredNode (location: (1376...1403))
        │   ├── value:
        │   │   @ CallNode (location: (1376...1379))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1376...1379) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (1383...1403))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (1383...1386))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (1387...1391))
        │   │   │   ├── operator_loc: (1387...1388) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1388...1391))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1393...1396))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (1398...1402))
        │   │   │   ├── operator_loc: (1398...1399) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1399...1402))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1386...1387) = "["
        │   │   └── closing_loc: (1402...1403) = "]"
        │   └── operator_loc: (1380...1382) = "=>"
        ├── @ MatchRequiredNode (location: (1405...1416))
        │   ├── value:
        │   │   @ CallNode (location: (1405...1408))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1405...1408) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1412...1416))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1412...1416))
        │   │   │   ├── operator_loc: (1412...1413) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1413...1416))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1409...1411) = "=>"
        ├── @ MatchRequiredNode (location: (1417...1438))
        │   ├── value:
        │   │   @ CallNode (location: (1417...1420))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1417...1420) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1424...1438))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1424...1428))
        │   │   │   ├── operator_loc: (1424...1425) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1425...1428))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (1430...1433))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (1435...1438))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1421...1423) = "=>"
        ├── @ MatchRequiredNode (location: (1439...1460))
        │   ├── value:
        │   │   @ CallNode (location: (1439...1442))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1439...1442) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1446...1460))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1446...1449))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1451...1455))
        │   │   │   ├── operator_loc: (1451...1452) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1452...1455))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1457...1460))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1443...1445) = "=>"
        ├── @ MatchRequiredNode (location: (1461...1482))
        │   ├── value:
        │   │   @ CallNode (location: (1461...1464))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1461...1464) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1468...1482))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (1468...1471))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (1473...1476))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1478...1482))
        │   │   │   ├── operator_loc: (1478...1479) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1479...1482))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1465...1467) = "=>"
        ├── @ MatchRequiredNode (location: (1483...1505))
        │   ├── value:
        │   │   @ CallNode (location: (1483...1486))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1483...1486) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (1490...1505))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (1490...1494))
        │   │   │   ├── operator_loc: (1490...1491) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1491...1494))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1496...1499))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (1501...1505))
        │   │   │   ├── operator_loc: (1501...1502) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1502...1505))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1487...1489) = "=>"
        ├── @ MatchRequiredNode (location: (1507...1516))
        │   ├── value:
        │   │   @ CallNode (location: (1507...1510))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1507...1510) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1514...1516))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1514...1515) = "["
        │   │   └── closing_loc: (1515...1516) = "]"
        │   └── operator_loc: (1511...1513) = "=>"
        ├── @ MatchRequiredNode (location: (1517...1534))
        │   ├── value:
        │   │   @ CallNode (location: (1517...1520))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1517...1520) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1524...1534))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (1525...1533))
        │   │   │       ├── constant: ∅
        │   │   │       ├── requireds: (length: 1)
        │   │   │       │   └── @ ArrayPatternNode (location: (1526...1532))
        │   │   │       │       ├── constant: ∅
        │   │   │       │       ├── requireds: (length: 1)
        │   │   │       │       │   └── @ ArrayPatternNode (location: (1527...1531))
        │   │   │       │       │       ├── constant: ∅
        │   │   │       │       │       ├── requireds: (length: 1)
        │   │   │       │       │       │   └── @ ArrayPatternNode (location: (1528...1530))
        │   │   │       │       │       │       ├── constant: ∅
        │   │   │       │       │       │       ├── requireds: (length: 0)
        │   │   │       │       │       │       ├── rest: ∅
        │   │   │       │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       │       ├── opening_loc: (1528...1529) = "["
        │   │   │       │       │       │       └── closing_loc: (1529...1530) = "]"
        │   │   │       │       │       ├── rest: ∅
        │   │   │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       ├── opening_loc: (1527...1528) = "["
        │   │   │       │       │       └── closing_loc: (1530...1531) = "]"
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── posts: (length: 0)
        │   │   │       │       ├── opening_loc: (1526...1527) = "["
        │   │   │       │       └── closing_loc: (1531...1532) = "]"
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (1525...1526) = "["
        │   │   │       └── closing_loc: (1532...1533) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1524...1525) = "["
        │   │   └── closing_loc: (1533...1534) = "]"
        │   └── operator_loc: (1521...1523) = "=>"
        ├── @ MatchRequiredNode (location: (1536...1549))
        │   ├── value:
        │   │   @ CallNode (location: (1536...1539))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1536...1539) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1543...1549))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1544...1548))
        │   │   │   ├── operator_loc: (1544...1545) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1545...1548))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1543...1544) = "["
        │   │   └── closing_loc: (1548...1549) = "]"
        │   └── operator_loc: (1540...1542) = "=>"
        ├── @ MatchRequiredNode (location: (1550...1573))
        │   ├── value:
        │   │   @ CallNode (location: (1550...1553))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1550...1553) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1557...1573))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1558...1562))
        │   │   │   ├── operator_loc: (1558...1559) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1559...1562))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (1564...1567))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (1569...1572))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1557...1558) = "["
        │   │   └── closing_loc: (1572...1573) = "]"
        │   └── operator_loc: (1554...1556) = "=>"
        ├── @ MatchRequiredNode (location: (1574...1597))
        │   ├── value:
        │   │   @ CallNode (location: (1574...1577))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1574...1577) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1581...1597))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1582...1585))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1587...1591))
        │   │   │   ├── operator_loc: (1587...1588) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1588...1591))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1593...1596))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1581...1582) = "["
        │   │   └── closing_loc: (1596...1597) = "]"
        │   └── operator_loc: (1578...1580) = "=>"
        ├── @ MatchRequiredNode (location: (1598...1621))
        │   ├── value:
        │   │   @ CallNode (location: (1598...1601))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1598...1601) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1605...1621))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (1606...1609))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (1611...1614))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (1616...1620))
        │   │   │   ├── operator_loc: (1616...1617) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1617...1620))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1605...1606) = "["
        │   │   └── closing_loc: (1620...1621) = "]"
        │   └── operator_loc: (1602...1604) = "=>"
        ├── @ MatchRequiredNode (location: (1622...1646))
        │   ├── value:
        │   │   @ CallNode (location: (1622...1625))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1622...1625) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (1629...1646))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (1630...1634))
        │   │   │   ├── operator_loc: (1630...1631) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1631...1634))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1636...1639))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (1641...1645))
        │   │   │   ├── operator_loc: (1641...1642) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (1642...1645))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (1629...1630) = "["
        │   │   └── closing_loc: (1645...1646) = "]"
        │   └── operator_loc: (1626...1628) = "=>"
        ├── @ MatchPredicateNode (location: (1648...1658))
        │   ├── value:
        │   │   @ CallNode (location: (1648...1651))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1648...1651) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (1655...1658))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (1652...1654) = "in"
        ├── @ MatchPredicateNode (location: (1659...1667))
        │   ├── value:
        │   │   @ CallNode (location: (1659...1662))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1659...1662) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ IntegerNode (location: (1666...1667))
        │   │   └── flags: decimal
        │   └── operator_loc: (1663...1665) = "in"
        ├── @ MatchPredicateNode (location: (1668...1678))
        │   ├── value:
        │   │   @ CallNode (location: (1668...1671))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1668...1671) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FloatNode (location: (1675...1678))
        │   └── operator_loc: (1672...1674) = "in"
        ├── @ MatchPredicateNode (location: (1679...1688))
        │   ├── value:
        │   │   @ CallNode (location: (1679...1682))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1679...1682) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (1686...1688))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (1686...1687))
        │   │       └── flags: decimal
        │   └── operator_loc: (1683...1685) = "in"
        ├── @ MatchPredicateNode (location: (1689...1698))
        │   ├── value:
        │   │   @ CallNode (location: (1689...1692))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1689...1692) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RationalNode (location: (1696...1698))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (1696...1697))
        │   │       └── flags: decimal
        │   └── operator_loc: (1693...1695) = "in"
        ├── @ MatchPredicateNode (location: (1699...1710))
        │   ├── value:
        │   │   @ CallNode (location: (1699...1702))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1699...1702) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (1706...1710))
        │   │   ├── opening_loc: (1706...1707) = ":"
        │   │   ├── value_loc: (1707...1710) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1703...1705) = "in"
        ├── @ MatchPredicateNode (location: (1711...1725))
        │   ├── value:
        │   │   @ CallNode (location: (1711...1714))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1711...1714) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (1718...1725))
        │   │   ├── opening_loc: (1718...1721) = "%s["
        │   │   ├── value_loc: (1721...1724) = "foo"
        │   │   ├── closing_loc: (1724...1725) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1715...1717) = "in"
        ├── @ MatchPredicateNode (location: (1726...1739))
        │   ├── value:
        │   │   @ CallNode (location: (1726...1729))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1726...1729) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SymbolNode (location: (1733...1739))
        │   │   ├── opening_loc: (1733...1735) = ":\""
        │   │   ├── value_loc: (1735...1738) = "foo"
        │   │   ├── closing_loc: (1738...1739) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1730...1732) = "in"
        ├── @ MatchPredicateNode (location: (1740...1752))
        │   ├── value:
        │   │   @ CallNode (location: (1740...1743))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1740...1743) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (1747...1752))
        │   │   ├── opening_loc: (1747...1748) = "/"
        │   │   ├── content_loc: (1748...1751) = "foo"
        │   │   ├── closing_loc: (1751...1752) = "/"
        │   │   ├── unescaped: "foo"
        │   │   └── flags: ∅
        │   └── operator_loc: (1744...1746) = "in"
        ├── @ MatchPredicateNode (location: (1753...1765))
        │   ├── value:
        │   │   @ CallNode (location: (1753...1756))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1753...1756) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ XStringNode (location: (1760...1765))
        │   │   ├── opening_loc: (1760...1761) = "`"
        │   │   ├── content_loc: (1761...1764) = "foo"
        │   │   ├── closing_loc: (1764...1765) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1757...1759) = "in"
        ├── @ MatchPredicateNode (location: (1766...1780))
        │   ├── value:
        │   │   @ CallNode (location: (1766...1769))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1766...1769) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ XStringNode (location: (1773...1780))
        │   │   ├── opening_loc: (1773...1776) = "%x["
        │   │   ├── content_loc: (1776...1779) = "foo"
        │   │   ├── closing_loc: (1779...1780) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1770...1772) = "in"
        ├── @ MatchPredicateNode (location: (1781...1795))
        │   ├── value:
        │   │   @ CallNode (location: (1781...1784))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1781...1784) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (1788...1795))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (1791...1794))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (1791...1794) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (1788...1791) = "%i["
        │   │   └── closing_loc: (1794...1795) = "]"
        │   └── operator_loc: (1785...1787) = "in"
        ├── @ MatchPredicateNode (location: (1796...1810))
        │   ├── value:
        │   │   @ CallNode (location: (1796...1799))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1796...1799) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (1803...1810))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (1806...1809))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (1806...1809) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (1803...1806) = "%I["
        │   │   └── closing_loc: (1809...1810) = "]"
        │   └── operator_loc: (1800...1802) = "in"
        ├── @ MatchPredicateNode (location: (1811...1825))
        │   ├── value:
        │   │   @ CallNode (location: (1811...1814))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1811...1814) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (1818...1825))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (1821...1824))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (1821...1824) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (1818...1821) = "%w["
        │   │   └── closing_loc: (1824...1825) = "]"
        │   └── operator_loc: (1815...1817) = "in"
        ├── @ MatchPredicateNode (location: (1826...1840))
        │   ├── value:
        │   │   @ CallNode (location: (1826...1829))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1826...1829) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ ArrayNode (location: (1833...1840))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (1836...1839))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (1836...1839) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (1833...1836) = "%W["
        │   │   └── closing_loc: (1839...1840) = "]"
        │   └── operator_loc: (1830...1832) = "in"
        ├── @ MatchPredicateNode (location: (1841...1855))
        │   ├── value:
        │   │   @ CallNode (location: (1841...1844))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1841...1844) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (1848...1855))
        │   │   ├── opening_loc: (1848...1851) = "%q["
        │   │   ├── content_loc: (1851...1854) = "foo"
        │   │   ├── closing_loc: (1854...1855) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1845...1847) = "in"
        ├── @ MatchPredicateNode (location: (1856...1870))
        │   ├── value:
        │   │   @ CallNode (location: (1856...1859))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1856...1859) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (1863...1870))
        │   │   ├── opening_loc: (1863...1866) = "%Q["
        │   │   ├── content_loc: (1866...1869) = "foo"
        │   │   ├── closing_loc: (1869...1870) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1860...1862) = "in"
        ├── @ MatchPredicateNode (location: (1871...1883))
        │   ├── value:
        │   │   @ CallNode (location: (1871...1874))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1871...1874) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ StringNode (location: (1878...1883))
        │   │   ├── opening_loc: (1878...1879) = "\""
        │   │   ├── content_loc: (1879...1882) = "foo"
        │   │   ├── closing_loc: (1882...1883) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (1875...1877) = "in"
        ├── @ MatchPredicateNode (location: (1884...1894))
        │   ├── value:
        │   │   @ CallNode (location: (1884...1887))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1884...1887) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ NilNode (location: (1891...1894))
        │   └── operator_loc: (1888...1890) = "in"
        ├── @ MatchPredicateNode (location: (1895...1906))
        │   ├── value:
        │   │   @ CallNode (location: (1895...1898))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1895...1898) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SelfNode (location: (1902...1906))
        │   └── operator_loc: (1899...1901) = "in"
        ├── @ MatchPredicateNode (location: (1907...1918))
        │   ├── value:
        │   │   @ CallNode (location: (1907...1910))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1907...1910) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ TrueNode (location: (1914...1918))
        │   └── operator_loc: (1911...1913) = "in"
        ├── @ MatchPredicateNode (location: (1919...1931))
        │   ├── value:
        │   │   @ CallNode (location: (1919...1922))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1919...1922) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ FalseNode (location: (1926...1931))
        │   └── operator_loc: (1923...1925) = "in"
        ├── @ MatchPredicateNode (location: (1932...1947))
        │   ├── value:
        │   │   @ CallNode (location: (1932...1935))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1932...1935) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (1939...1947))
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (1936...1938) = "in"
        ├── @ MatchPredicateNode (location: (1948...1963))
        │   ├── value:
        │   │   @ CallNode (location: (1948...1951))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1948...1951) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (1955...1963))
        │   └── operator_loc: (1952...1954) = "in"
        ├── @ MatchPredicateNode (location: (1964...1983))
        │   ├── value:
        │   │   @ CallNode (location: (1964...1967))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1964...1967) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (1971...1983))
        │   └── operator_loc: (1968...1970) = "in"
        ├── @ MatchPredicateNode (location: (1984...2001))
        │   ├── value:
        │   │   @ CallNode (location: (1984...1987))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1984...1987) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── pattern:
        │   │   @ LambdaNode (location: (1991...2001))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (1991...1993) = "->"
        │   │   ├── opening_loc: (1994...1995) = "{"
        │   │   ├── closing_loc: (2000...2001) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (1996...1999))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (1996...1999))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (1988...1990) = "in"
        ├── @ CaseNode (location: (2003...2028))
        │   ├── predicate:
        │   │   @ CallNode (location: (2008...2011))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2008...2011) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2013...2024))
        │   │       ├── pattern:
        │   │       │   @ LocalVariableTargetNode (location: (2016...2019))
        │   │       │   ├── name: :bar
        │   │       │   └── depth: 0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2013...2015) = "in"
        │   │       └── then_loc: (2020...2024) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2003...2007) = "case"
        │   └── end_keyword_loc: (2025...2028) = "end"
        ├── @ CaseNode (location: (2029...2052))
        │   ├── predicate:
        │   │   @ CallNode (location: (2034...2037))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2034...2037) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2039...2048))
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (2042...2043))
        │   │       │   └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2039...2041) = "in"
        │   │       └── then_loc: (2044...2048) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2029...2033) = "case"
        │   └── end_keyword_loc: (2049...2052) = "end"
        ├── @ CaseNode (location: (2053...2078))
        │   ├── predicate:
        │   │   @ CallNode (location: (2058...2061))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2058...2061) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2063...2074))
        │   │       ├── pattern:
        │   │       │   @ FloatNode (location: (2066...2069))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2063...2065) = "in"
        │   │       └── then_loc: (2070...2074) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2053...2057) = "case"
        │   └── end_keyword_loc: (2075...2078) = "end"
        ├── @ CaseNode (location: (2079...2103))
        │   ├── predicate:
        │   │   @ CallNode (location: (2084...2087))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2084...2087) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2089...2099))
        │   │       ├── pattern:
        │   │       │   @ ImaginaryNode (location: (2092...2094))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (2092...2093))
        │   │       │       └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2089...2091) = "in"
        │   │       └── then_loc: (2095...2099) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2079...2083) = "case"
        │   └── end_keyword_loc: (2100...2103) = "end"
        ├── @ CaseNode (location: (2104...2128))
        │   ├── predicate:
        │   │   @ CallNode (location: (2109...2112))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2109...2112) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2114...2124))
        │   │       ├── pattern:
        │   │       │   @ RationalNode (location: (2117...2119))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (2117...2118))
        │   │       │       └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2114...2116) = "in"
        │   │       └── then_loc: (2120...2124) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2104...2108) = "case"
        │   └── end_keyword_loc: (2125...2128) = "end"
        ├── @ CaseNode (location: (2129...2155))
        │   ├── predicate:
        │   │   @ CallNode (location: (2134...2137))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2134...2137) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2139...2151))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (2142...2146))
        │   │       │   ├── opening_loc: (2142...2143) = ":"
        │   │       │   ├── value_loc: (2143...2146) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2139...2141) = "in"
        │   │       └── then_loc: (2147...2151) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2129...2133) = "case"
        │   └── end_keyword_loc: (2152...2155) = "end"
        ├── @ CaseNode (location: (2156...2185))
        │   ├── predicate:
        │   │   @ CallNode (location: (2161...2164))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2161...2164) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2166...2181))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (2169...2176))
        │   │       │   ├── opening_loc: (2169...2172) = "%s["
        │   │       │   ├── value_loc: (2172...2175) = "foo"
        │   │       │   ├── closing_loc: (2175...2176) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2166...2168) = "in"
        │   │       └── then_loc: (2177...2181) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2156...2160) = "case"
        │   └── end_keyword_loc: (2182...2185) = "end"
        ├── @ CaseNode (location: (2186...2214))
        │   ├── predicate:
        │   │   @ CallNode (location: (2191...2194))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2191...2194) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2196...2210))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (2199...2205))
        │   │       │   ├── opening_loc: (2199...2201) = ":\""
        │   │       │   ├── value_loc: (2201...2204) = "foo"
        │   │       │   ├── closing_loc: (2204...2205) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2196...2198) = "in"
        │   │       └── then_loc: (2206...2210) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2186...2190) = "case"
        │   └── end_keyword_loc: (2211...2214) = "end"
        ├── @ CaseNode (location: (2215...2242))
        │   ├── predicate:
        │   │   @ CallNode (location: (2220...2223))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2220...2223) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2225...2238))
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (2228...2233))
        │   │       │   ├── opening_loc: (2228...2229) = "/"
        │   │       │   ├── content_loc: (2229...2232) = "foo"
        │   │       │   ├── closing_loc: (2232...2233) = "/"
        │   │       │   ├── unescaped: "foo"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2225...2227) = "in"
        │   │       └── then_loc: (2234...2238) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2215...2219) = "case"
        │   └── end_keyword_loc: (2239...2242) = "end"
        ├── @ CaseNode (location: (2243...2270))
        │   ├── predicate:
        │   │   @ CallNode (location: (2248...2251))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2248...2251) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2253...2266))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (2256...2261))
        │   │       │   ├── opening_loc: (2256...2257) = "`"
        │   │       │   ├── content_loc: (2257...2260) = "foo"
        │   │       │   ├── closing_loc: (2260...2261) = "`"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2253...2255) = "in"
        │   │       └── then_loc: (2262...2266) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2243...2247) = "case"
        │   └── end_keyword_loc: (2267...2270) = "end"
        ├── @ CaseNode (location: (2271...2300))
        │   ├── predicate:
        │   │   @ CallNode (location: (2276...2279))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2276...2279) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2281...2296))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (2284...2291))
        │   │       │   ├── opening_loc: (2284...2287) = "%x["
        │   │       │   ├── content_loc: (2287...2290) = "foo"
        │   │       │   ├── closing_loc: (2290...2291) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2281...2283) = "in"
        │   │       └── then_loc: (2292...2296) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2271...2275) = "case"
        │   └── end_keyword_loc: (2297...2300) = "end"
        ├── @ CaseNode (location: (2301...2330))
        │   ├── predicate:
        │   │   @ CallNode (location: (2306...2309))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2306...2309) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2311...2326))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (2314...2321))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (2317...2320))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (2317...2320) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (2314...2317) = "%i["
        │   │       │   └── closing_loc: (2320...2321) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2311...2313) = "in"
        │   │       └── then_loc: (2322...2326) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2301...2305) = "case"
        │   └── end_keyword_loc: (2327...2330) = "end"
        ├── @ CaseNode (location: (2331...2360))
        │   ├── predicate:
        │   │   @ CallNode (location: (2336...2339))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2336...2339) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2341...2356))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (2344...2351))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (2347...2350))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (2347...2350) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (2344...2347) = "%I["
        │   │       │   └── closing_loc: (2350...2351) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2341...2343) = "in"
        │   │       └── then_loc: (2352...2356) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2331...2335) = "case"
        │   └── end_keyword_loc: (2357...2360) = "end"
        ├── @ CaseNode (location: (2361...2390))
        │   ├── predicate:
        │   │   @ CallNode (location: (2366...2369))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2366...2369) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2371...2386))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (2374...2381))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (2377...2380))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (2377...2380) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (2374...2377) = "%w["
        │   │       │   └── closing_loc: (2380...2381) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2371...2373) = "in"
        │   │       └── then_loc: (2382...2386) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2361...2365) = "case"
        │   └── end_keyword_loc: (2387...2390) = "end"
        ├── @ CaseNode (location: (2391...2420))
        │   ├── predicate:
        │   │   @ CallNode (location: (2396...2399))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2396...2399) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2401...2416))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (2404...2411))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (2407...2410))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (2407...2410) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (2404...2407) = "%W["
        │   │       │   └── closing_loc: (2410...2411) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2401...2403) = "in"
        │   │       └── then_loc: (2412...2416) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2391...2395) = "case"
        │   └── end_keyword_loc: (2417...2420) = "end"
        ├── @ CaseNode (location: (2421...2450))
        │   ├── predicate:
        │   │   @ CallNode (location: (2426...2429))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2426...2429) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2431...2446))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (2434...2441))
        │   │       │   ├── opening_loc: (2434...2437) = "%q["
        │   │       │   ├── content_loc: (2437...2440) = "foo"
        │   │       │   ├── closing_loc: (2440...2441) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2431...2433) = "in"
        │   │       └── then_loc: (2442...2446) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2421...2425) = "case"
        │   └── end_keyword_loc: (2447...2450) = "end"
        ├── @ CaseNode (location: (2451...2480))
        │   ├── predicate:
        │   │   @ CallNode (location: (2456...2459))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2456...2459) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2461...2476))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (2464...2471))
        │   │       │   ├── opening_loc: (2464...2467) = "%Q["
        │   │       │   ├── content_loc: (2467...2470) = "foo"
        │   │       │   ├── closing_loc: (2470...2471) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2461...2463) = "in"
        │   │       └── then_loc: (2472...2476) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2451...2455) = "case"
        │   └── end_keyword_loc: (2477...2480) = "end"
        ├── @ CaseNode (location: (2481...2508))
        │   ├── predicate:
        │   │   @ CallNode (location: (2486...2489))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2486...2489) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2491...2504))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (2494...2499))
        │   │       │   ├── opening_loc: (2494...2495) = "\""
        │   │       │   ├── content_loc: (2495...2498) = "foo"
        │   │       │   ├── closing_loc: (2498...2499) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2491...2493) = "in"
        │   │       └── then_loc: (2500...2504) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2481...2485) = "case"
        │   └── end_keyword_loc: (2505...2508) = "end"
        ├── @ CaseNode (location: (2509...2534))
        │   ├── predicate:
        │   │   @ CallNode (location: (2514...2517))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2514...2517) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2519...2530))
        │   │       ├── pattern:
        │   │       │   @ NilNode (location: (2522...2525))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2519...2521) = "in"
        │   │       └── then_loc: (2526...2530) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2509...2513) = "case"
        │   └── end_keyword_loc: (2531...2534) = "end"
        ├── @ CaseNode (location: (2535...2561))
        │   ├── predicate:
        │   │   @ CallNode (location: (2540...2543))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2540...2543) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2545...2557))
        │   │       ├── pattern:
        │   │       │   @ SelfNode (location: (2548...2552))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2545...2547) = "in"
        │   │       └── then_loc: (2553...2557) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2535...2539) = "case"
        │   └── end_keyword_loc: (2558...2561) = "end"
        ├── @ CaseNode (location: (2562...2588))
        │   ├── predicate:
        │   │   @ CallNode (location: (2567...2570))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2567...2570) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2572...2584))
        │   │       ├── pattern:
        │   │       │   @ TrueNode (location: (2575...2579))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2572...2574) = "in"
        │   │       └── then_loc: (2580...2584) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2562...2566) = "case"
        │   └── end_keyword_loc: (2585...2588) = "end"
        ├── @ CaseNode (location: (2589...2616))
        │   ├── predicate:
        │   │   @ CallNode (location: (2594...2597))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2594...2597) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2599...2612))
        │   │       ├── pattern:
        │   │       │   @ FalseNode (location: (2602...2607))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2599...2601) = "in"
        │   │       └── then_loc: (2608...2612) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2589...2593) = "case"
        │   └── end_keyword_loc: (2613...2616) = "end"
        ├── @ CaseNode (location: (2617...2647))
        │   ├── predicate:
        │   │   @ CallNode (location: (2622...2625))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2622...2625) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2627...2643))
        │   │       ├── pattern:
        │   │       │   @ SourceFileNode (location: (2630...2638))
        │   │       │   └── filepath: "patterns.txt"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2627...2629) = "in"
        │   │       └── then_loc: (2639...2643) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2617...2621) = "case"
        │   └── end_keyword_loc: (2644...2647) = "end"
        ├── @ CaseNode (location: (2648...2678))
        │   ├── predicate:
        │   │   @ CallNode (location: (2653...2656))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2653...2656) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2658...2674))
        │   │       ├── pattern:
        │   │       │   @ SourceLineNode (location: (2661...2669))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2658...2660) = "in"
        │   │       └── then_loc: (2670...2674) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2648...2652) = "case"
        │   └── end_keyword_loc: (2675...2678) = "end"
        ├── @ CaseNode (location: (2679...2713))
        │   ├── predicate:
        │   │   @ CallNode (location: (2684...2687))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2684...2687) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2689...2709))
        │   │       ├── pattern:
        │   │       │   @ SourceEncodingNode (location: (2692...2704))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2689...2691) = "in"
        │   │       └── then_loc: (2705...2709) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2679...2683) = "case"
        │   └── end_keyword_loc: (2710...2713) = "end"
        ├── @ CaseNode (location: (2714...2746))
        │   ├── predicate:
        │   │   @ CallNode (location: (2719...2722))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2719...2722) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2724...2742))
        │   │       ├── pattern:
        │   │       │   @ LambdaNode (location: (2727...2737))
        │   │       │   ├── locals: []
        │   │       │   ├── operator_loc: (2727...2729) = "->"
        │   │       │   ├── opening_loc: (2730...2731) = "{"
        │   │       │   ├── closing_loc: (2736...2737) = "}"
        │   │       │   ├── parameters: ∅
        │   │       │   └── body:
        │   │       │       @ StatementsNode (location: (2732...2735))
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ LocalVariableReadNode (location: (2732...2735))
        │   │       │               ├── name: :bar
        │   │       │               └── depth: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2724...2726) = "in"
        │   │       └── then_loc: (2738...2742) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2714...2718) = "case"
        │   └── end_keyword_loc: (2743...2746) = "end"
        ├── @ CaseNode (location: (2748...2780))
        │   ├── predicate:
        │   │   @ CallNode (location: (2753...2756))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2753...2756) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2758...2776))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2761...2771))
        │   │       │   ├── if_keyword_loc: (2765...2767) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2768...2771))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2761...2764))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (2761...2764))
        │   │       │   │           ├── name: :bar
        │   │       │   │           └── depth: 0
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2758...2760) = "in"
        │   │       └── then_loc: (2772...2776) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2748...2752) = "case"
        │   └── end_keyword_loc: (2777...2780) = "end"
        ├── @ CaseNode (location: (2781...2811))
        │   ├── predicate:
        │   │   @ CallNode (location: (2786...2789))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2786...2789) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2791...2807))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2794...2802))
        │   │       │   ├── if_keyword_loc: (2796...2798) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2799...2802))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2794...2795))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (2794...2795))
        │   │       │   │           └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2791...2793) = "in"
        │   │       └── then_loc: (2803...2807) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2781...2785) = "case"
        │   └── end_keyword_loc: (2808...2811) = "end"
        ├── @ CaseNode (location: (2812...2844))
        │   ├── predicate:
        │   │   @ CallNode (location: (2817...2820))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2817...2820) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2822...2840))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2825...2835))
        │   │       │   ├── if_keyword_loc: (2829...2831) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2832...2835))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2825...2828))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FloatNode (location: (2825...2828))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2822...2824) = "in"
        │   │       └── then_loc: (2836...2840) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2812...2816) = "case"
        │   └── end_keyword_loc: (2841...2844) = "end"
        ├── @ CaseNode (location: (2845...2876))
        │   ├── predicate:
        │   │   @ CallNode (location: (2850...2853))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2850...2853) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2855...2872))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2858...2867))
        │   │       │   ├── if_keyword_loc: (2861...2863) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2864...2867))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2858...2860))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ImaginaryNode (location: (2858...2860))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (2858...2859))
        │   │       │   │               └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2855...2857) = "in"
        │   │       └── then_loc: (2868...2872) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2845...2849) = "case"
        │   └── end_keyword_loc: (2873...2876) = "end"
        ├── @ CaseNode (location: (2877...2908))
        │   ├── predicate:
        │   │   @ CallNode (location: (2882...2885))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2882...2885) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2887...2904))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2890...2899))
        │   │       │   ├── if_keyword_loc: (2893...2895) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2896...2899))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2890...2892))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RationalNode (location: (2890...2892))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (2890...2891))
        │   │       │   │               └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2887...2889) = "in"
        │   │       └── then_loc: (2900...2904) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2877...2881) = "case"
        │   └── end_keyword_loc: (2905...2908) = "end"
        ├── @ CaseNode (location: (2909...2942))
        │   ├── predicate:
        │   │   @ CallNode (location: (2914...2917))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2914...2917) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2919...2938))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2922...2933))
        │   │       │   ├── if_keyword_loc: (2927...2929) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2930...2933))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2922...2926))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (2922...2926))
        │   │       │   │           ├── opening_loc: (2922...2923) = ":"
        │   │       │   │           ├── value_loc: (2923...2926) = "foo"
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2919...2921) = "in"
        │   │       └── then_loc: (2934...2938) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2909...2913) = "case"
        │   └── end_keyword_loc: (2939...2942) = "end"
        ├── @ CaseNode (location: (2943...2979))
        │   ├── predicate:
        │   │   @ CallNode (location: (2948...2951))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2948...2951) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2953...2975))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2956...2970))
        │   │       │   ├── if_keyword_loc: (2964...2966) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (2967...2970))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2956...2963))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (2956...2963))
        │   │       │   │           ├── opening_loc: (2956...2959) = "%s["
        │   │       │   │           ├── value_loc: (2959...2962) = "foo"
        │   │       │   │           ├── closing_loc: (2962...2963) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2953...2955) = "in"
        │   │       └── then_loc: (2971...2975) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2943...2947) = "case"
        │   └── end_keyword_loc: (2976...2979) = "end"
        ├── @ CaseNode (location: (2980...3015))
        │   ├── predicate:
        │   │   @ CallNode (location: (2985...2988))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (2985...2988) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2990...3011))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (2993...3006))
        │   │       │   ├── if_keyword_loc: (3000...3002) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3003...3006))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (2993...2999))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (2993...2999))
        │   │       │   │           ├── opening_loc: (2993...2995) = ":\""
        │   │       │   │           ├── value_loc: (2995...2998) = "foo"
        │   │       │   │           ├── closing_loc: (2998...2999) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2990...2992) = "in"
        │   │       └── then_loc: (3007...3011) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (2980...2984) = "case"
        │   └── end_keyword_loc: (3012...3015) = "end"
        ├── @ CaseNode (location: (3016...3050))
        │   ├── predicate:
        │   │   @ CallNode (location: (3021...3024))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3021...3024) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3026...3046))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3029...3041))
        │   │       │   ├── if_keyword_loc: (3035...3037) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3038...3041))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3029...3034))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RegularExpressionNode (location: (3029...3034))
        │   │       │   │           ├── opening_loc: (3029...3030) = "/"
        │   │       │   │           ├── content_loc: (3030...3033) = "foo"
        │   │       │   │           ├── closing_loc: (3033...3034) = "/"
        │   │       │   │           ├── unescaped: "foo"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3026...3028) = "in"
        │   │       └── then_loc: (3042...3046) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3016...3020) = "case"
        │   └── end_keyword_loc: (3047...3050) = "end"
        ├── @ CaseNode (location: (3051...3085))
        │   ├── predicate:
        │   │   @ CallNode (location: (3056...3059))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3056...3059) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3061...3081))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3064...3076))
        │   │       │   ├── if_keyword_loc: (3070...3072) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3073...3076))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3064...3069))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (3064...3069))
        │   │       │   │           ├── opening_loc: (3064...3065) = "`"
        │   │       │   │           ├── content_loc: (3065...3068) = "foo"
        │   │       │   │           ├── closing_loc: (3068...3069) = "`"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3061...3063) = "in"
        │   │       └── then_loc: (3077...3081) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3051...3055) = "case"
        │   └── end_keyword_loc: (3082...3085) = "end"
        ├── @ CaseNode (location: (3086...3122))
        │   ├── predicate:
        │   │   @ CallNode (location: (3091...3094))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3091...3094) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3096...3118))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3099...3113))
        │   │       │   ├── if_keyword_loc: (3107...3109) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3110...3113))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3099...3106))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (3099...3106))
        │   │       │   │           ├── opening_loc: (3099...3102) = "%x["
        │   │       │   │           ├── content_loc: (3102...3105) = "foo"
        │   │       │   │           ├── closing_loc: (3105...3106) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3096...3098) = "in"
        │   │       └── then_loc: (3114...3118) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3086...3090) = "case"
        │   └── end_keyword_loc: (3119...3122) = "end"
        ├── @ CaseNode (location: (3123...3159))
        │   ├── predicate:
        │   │   @ CallNode (location: (3128...3131))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3128...3131) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3133...3155))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3136...3150))
        │   │       │   ├── if_keyword_loc: (3144...3146) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3147...3150))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3136...3143))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (3136...3143))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (3139...3142))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (3139...3142) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (3136...3139) = "%i["
        │   │       │   │           └── closing_loc: (3142...3143) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3133...3135) = "in"
        │   │       └── then_loc: (3151...3155) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3123...3127) = "case"
        │   └── end_keyword_loc: (3156...3159) = "end"
        ├── @ CaseNode (location: (3160...3196))
        │   ├── predicate:
        │   │   @ CallNode (location: (3165...3168))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3165...3168) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3170...3192))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3173...3187))
        │   │       │   ├── if_keyword_loc: (3181...3183) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3184...3187))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3173...3180))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (3173...3180))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (3176...3179))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (3176...3179) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (3173...3176) = "%I["
        │   │       │   │           └── closing_loc: (3179...3180) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3170...3172) = "in"
        │   │       └── then_loc: (3188...3192) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3160...3164) = "case"
        │   └── end_keyword_loc: (3193...3196) = "end"
        ├── @ CaseNode (location: (3197...3233))
        │   ├── predicate:
        │   │   @ CallNode (location: (3202...3205))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3202...3205) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3207...3229))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3210...3224))
        │   │       │   ├── if_keyword_loc: (3218...3220) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3221...3224))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3210...3217))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (3210...3217))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (3213...3216))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (3213...3216) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (3210...3213) = "%w["
        │   │       │   │           └── closing_loc: (3216...3217) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3207...3209) = "in"
        │   │       └── then_loc: (3225...3229) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3197...3201) = "case"
        │   └── end_keyword_loc: (3230...3233) = "end"
        ├── @ CaseNode (location: (3234...3270))
        │   ├── predicate:
        │   │   @ CallNode (location: (3239...3242))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3239...3242) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3244...3266))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3247...3261))
        │   │       │   ├── if_keyword_loc: (3255...3257) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3258...3261))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3247...3254))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (3247...3254))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (3250...3253))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (3250...3253) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (3247...3250) = "%W["
        │   │       │   │           └── closing_loc: (3253...3254) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3244...3246) = "in"
        │   │       └── then_loc: (3262...3266) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3234...3238) = "case"
        │   └── end_keyword_loc: (3267...3270) = "end"
        ├── @ CaseNode (location: (3271...3307))
        │   ├── predicate:
        │   │   @ CallNode (location: (3276...3279))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3276...3279) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3281...3303))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3284...3298))
        │   │       │   ├── if_keyword_loc: (3292...3294) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3295...3298))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3284...3291))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (3284...3291))
        │   │       │   │           ├── opening_loc: (3284...3287) = "%q["
        │   │       │   │           ├── content_loc: (3287...3290) = "foo"
        │   │       │   │           ├── closing_loc: (3290...3291) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3281...3283) = "in"
        │   │       └── then_loc: (3299...3303) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3271...3275) = "case"
        │   └── end_keyword_loc: (3304...3307) = "end"
        ├── @ CaseNode (location: (3308...3344))
        │   ├── predicate:
        │   │   @ CallNode (location: (3313...3316))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3313...3316) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3318...3340))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3321...3335))
        │   │       │   ├── if_keyword_loc: (3329...3331) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3332...3335))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3321...3328))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (3321...3328))
        │   │       │   │           ├── opening_loc: (3321...3324) = "%Q["
        │   │       │   │           ├── content_loc: (3324...3327) = "foo"
        │   │       │   │           ├── closing_loc: (3327...3328) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3318...3320) = "in"
        │   │       └── then_loc: (3336...3340) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3308...3312) = "case"
        │   └── end_keyword_loc: (3341...3344) = "end"
        ├── @ CaseNode (location: (3345...3379))
        │   ├── predicate:
        │   │   @ CallNode (location: (3350...3353))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3350...3353) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3355...3375))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3358...3370))
        │   │       │   ├── if_keyword_loc: (3364...3366) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3367...3370))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3358...3363))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (3358...3363))
        │   │       │   │           ├── opening_loc: (3358...3359) = "\""
        │   │       │   │           ├── content_loc: (3359...3362) = "foo"
        │   │       │   │           ├── closing_loc: (3362...3363) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3355...3357) = "in"
        │   │       └── then_loc: (3371...3375) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3345...3349) = "case"
        │   └── end_keyword_loc: (3376...3379) = "end"
        ├── @ CaseNode (location: (3380...3412))
        │   ├── predicate:
        │   │   @ CallNode (location: (3385...3388))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3385...3388) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3390...3408))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3393...3403))
        │   │       │   ├── if_keyword_loc: (3397...3399) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3400...3403))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3393...3396))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ NilNode (location: (3393...3396))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3390...3392) = "in"
        │   │       └── then_loc: (3404...3408) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3380...3384) = "case"
        │   └── end_keyword_loc: (3409...3412) = "end"
        ├── @ CaseNode (location: (3413...3446))
        │   ├── predicate:
        │   │   @ CallNode (location: (3418...3421))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3418...3421) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3423...3442))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3426...3437))
        │   │       │   ├── if_keyword_loc: (3431...3433) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3434...3437))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3426...3430))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SelfNode (location: (3426...3430))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3423...3425) = "in"
        │   │       └── then_loc: (3438...3442) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3413...3417) = "case"
        │   └── end_keyword_loc: (3443...3446) = "end"
        ├── @ CaseNode (location: (3447...3480))
        │   ├── predicate:
        │   │   @ CallNode (location: (3452...3455))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3452...3455) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3457...3476))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3460...3471))
        │   │       │   ├── if_keyword_loc: (3465...3467) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3468...3471))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3460...3464))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ TrueNode (location: (3460...3464))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3457...3459) = "in"
        │   │       └── then_loc: (3472...3476) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3447...3451) = "case"
        │   └── end_keyword_loc: (3477...3480) = "end"
        ├── @ CaseNode (location: (3481...3515))
        │   ├── predicate:
        │   │   @ CallNode (location: (3486...3489))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3486...3489) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3491...3511))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3494...3506))
        │   │       │   ├── if_keyword_loc: (3500...3502) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3503...3506))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3494...3499))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FalseNode (location: (3494...3499))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3491...3493) = "in"
        │   │       └── then_loc: (3507...3511) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3481...3485) = "case"
        │   └── end_keyword_loc: (3512...3515) = "end"
        ├── @ CaseNode (location: (3516...3553))
        │   ├── predicate:
        │   │   @ CallNode (location: (3521...3524))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3521...3524) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3526...3549))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3529...3544))
        │   │       │   ├── if_keyword_loc: (3538...3540) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3541...3544))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3529...3537))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceFileNode (location: (3529...3537))
        │   │       │   │           └── filepath: "patterns.txt"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3526...3528) = "in"
        │   │       └── then_loc: (3545...3549) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3516...3520) = "case"
        │   └── end_keyword_loc: (3550...3553) = "end"
        ├── @ CaseNode (location: (3554...3591))
        │   ├── predicate:
        │   │   @ CallNode (location: (3559...3562))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3559...3562) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3564...3587))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3567...3582))
        │   │       │   ├── if_keyword_loc: (3576...3578) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3579...3582))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3567...3575))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceLineNode (location: (3567...3575))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3564...3566) = "in"
        │   │       └── then_loc: (3583...3587) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3554...3558) = "case"
        │   └── end_keyword_loc: (3588...3591) = "end"
        ├── @ CaseNode (location: (3592...3633))
        │   ├── predicate:
        │   │   @ CallNode (location: (3597...3600))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3597...3600) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3602...3629))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3605...3624))
        │   │       │   ├── if_keyword_loc: (3618...3620) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3621...3624))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3605...3617))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceEncodingNode (location: (3605...3617))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3602...3604) = "in"
        │   │       └── then_loc: (3625...3629) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3592...3596) = "case"
        │   └── end_keyword_loc: (3630...3633) = "end"
        ├── @ CaseNode (location: (3634...3673))
        │   ├── predicate:
        │   │   @ CallNode (location: (3639...3642))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3639...3642) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3644...3669))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (3647...3664))
        │   │       │   ├── if_keyword_loc: (3658...3660) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (3661...3664))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (3647...3657))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LambdaNode (location: (3647...3657))
        │   │       │   │           ├── locals: []
        │   │       │   │           ├── operator_loc: (3647...3649) = "->"
        │   │       │   │           ├── opening_loc: (3650...3651) = "{"
        │   │       │   │           ├── closing_loc: (3656...3657) = "}"
        │   │       │   │           ├── parameters: ∅
        │   │       │   │           └── body:
        │   │       │   │               @ StatementsNode (location: (3652...3655))
        │   │       │   │               └── body: (length: 1)
        │   │       │   │                   └── @ LocalVariableReadNode (location: (3652...3655))
        │   │       │   │                       ├── name: :bar
        │   │       │   │                       └── depth: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (3644...3646) = "in"
        │   │       └── then_loc: (3665...3669) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (3634...3638) = "case"
        │   └── end_keyword_loc: (3670...3673) = "end"
        ├── @ IfNode (location: (3675...3689))
        │   ├── if_keyword_loc: (3675...3677) = "if"
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (3678...3685))
        │   │   ├── value:
        │   │   │   @ CallNode (location: (3678...3679))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (3678...3679) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "a"
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (3683...3685))
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: (3683...3684) = "["
        │   │   │   └── closing_loc: (3684...3685) = "]"
        │   │   └── operator_loc: (3680...3682) = "in"
        │   ├── statements: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (3686...3689) = "end"
        ├── @ MatchRequiredNode (location: (3691...3703))
        │   ├── value:
        │   │   @ CallNode (location: (3691...3692))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3691...3692) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (3696...3703))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (3700...3701))
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (3696...3697) = "["
        │   │   └── closing_loc: (3702...3703) = "]"
        │   └── operator_loc: (3693...3695) = "=>"
        └── @ MatchPredicateNode (location: (3705...3743))
            ├── value:
            │   @ CallNode (location: (3705...3708))
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── message_loc: (3705...3708) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── block: ∅
            │   ├── flags: variable_call
            │   └── name: "foo"
            ├── pattern:
            │   @ HashPatternNode (location: (3712...3743))
            │   ├── constant:
            │   │   @ ConstantReadNode (location: (3712...3713))
            │   │   └── name: :A
            │   ├── assocs: (length: 1)
            │   │   └── @ AssocNode (location: (3717...3741))
            │   │       ├── key:
            │   │       │   @ SymbolNode (location: (3717...3721))
            │   │       │   ├── opening_loc: ∅
            │   │       │   ├── value_loc: (3717...3720) = "bar"
            │   │       │   ├── closing_loc: (3720...3721) = ":"
            │   │       │   └── unescaped: "bar"
            │   │       ├── value:
            │   │       │   @ HashPatternNode (location: (3722...3741))
            │   │       │   ├── constant:
            │   │       │   │   @ ConstantReadNode (location: (3722...3723))
            │   │       │   │   └── name: :B
            │   │       │   ├── assocs: (length: 1)
            │   │       │   │   └── @ AssocNode (location: (3729...3737))
            │   │       │   │       ├── key:
            │   │       │   │       │   @ SymbolNode (location: (3729...3735))
            │   │       │   │       │   ├── opening_loc: ∅
            │   │       │   │       │   ├── value_loc: (3729...3734) = "value"
            │   │       │   │       │   ├── closing_loc: (3734...3735) = ":"
            │   │       │   │       │   └── unescaped: "value"
            │   │       │   │       ├── value:
            │   │       │   │       │   @ LocalVariableTargetNode (location: (3736...3737))
            │   │       │   │       │   ├── name: :a
            │   │       │   │       │   └── depth: 0
            │   │       │   │       └── operator_loc: ∅
            │   │       │   ├── kwrest: ∅
            │   │       │   ├── opening_loc: (3723...3724) = "["
            │   │       │   └── closing_loc: (3740...3741) = "]"
            │   │       └── operator_loc: ∅
            │   ├── kwrest: ∅
            │   ├── opening_loc: (3713...3714) = "["
            │   └── closing_loc: (3742...3743) = "]"
            └── operator_loc: (3709...3711) = "in"
