path: root/test/prism/snapshots/patterns.txt

@ ProgramNode (location: (1,0)-(200,3))
├── locals: [:bar, :baz, :qux, :b, :a, :foo]
└── statements:
    @ StatementsNode (location: (1,0)-(200,3))
    └── body: (length: 174)
        ├── @ MatchRequiredNode (location: (1,0)-(1,10))
        │   ├── value:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (1,7)-(1,10))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (1,4)-(1,6) = "=>"
        ├── @ MatchRequiredNode (location: (2,0)-(2,8))
        │   ├── value:
        │   │   @ CallNode (location: (2,0)-(2,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (2,0)-(2,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ IntegerNode (location: (2,7)-(2,8))
        │   │   └── flags: decimal
        │   └── operator_loc: (2,4)-(2,6) = "=>"
        ├── @ MatchRequiredNode (location: (3,0)-(3,10))
        │   ├── value:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FloatNode (location: (3,7)-(3,10))
        │   └── operator_loc: (3,4)-(3,6) = "=>"
        ├── @ MatchRequiredNode (location: (4,0)-(4,9))
        │   ├── value:
        │   │   @ CallNode (location: (4,0)-(4,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (4,0)-(4,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (4,7)-(4,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (4,7)-(4,8))
        │   │       └── flags: decimal
        │   └── operator_loc: (4,4)-(4,6) = "=>"
        ├── @ MatchRequiredNode (location: (5,0)-(5,9))
        │   ├── value:
        │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RationalNode (location: (5,7)-(5,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (5,7)-(5,8))
        │   │       └── flags: decimal
        │   └── operator_loc: (5,4)-(5,6) = "=>"
        ├── @ MatchRequiredNode (location: (6,0)-(6,11))
        │   ├── value:
        │   │   @ CallNode (location: (6,0)-(6,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (6,0)-(6,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (6,7)-(6,11))
        │   │   ├── opening_loc: (6,7)-(6,8) = ":"
        │   │   ├── value_loc: (6,8)-(6,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (6,4)-(6,6) = "=>"
        ├── @ MatchRequiredNode (location: (7,0)-(7,14))
        │   ├── value:
        │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (7,7)-(7,14))
        │   │   ├── opening_loc: (7,7)-(7,10) = "%s["
        │   │   ├── value_loc: (7,10)-(7,13) = "foo"
        │   │   ├── closing_loc: (7,13)-(7,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (7,4)-(7,6) = "=>"
        ├── @ MatchRequiredNode (location: (8,0)-(8,13))
        │   ├── value:
        │   │   @ CallNode (location: (8,0)-(8,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (8,0)-(8,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (8,7)-(8,13))
        │   │   ├── opening_loc: (8,7)-(8,9) = ":\""
        │   │   ├── value_loc: (8,9)-(8,12) = "foo"
        │   │   ├── closing_loc: (8,12)-(8,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (8,4)-(8,6) = "=>"
        ├── @ MatchRequiredNode (location: (9,0)-(9,12))
        │   ├── value:
        │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (9,7)-(9,12))
        │   │   ├── opening_loc: (9,7)-(9,8) = "/"
        │   │   ├── content_loc: (9,8)-(9,11) = "foo"
        │   │   ├── closing_loc: (9,11)-(9,12) = "/"
        │   │   ├── unescaped: "foo"
        │   │   └── flags: ∅
        │   └── operator_loc: (9,4)-(9,6) = "=>"
        ├── @ MatchRequiredNode (location: (10,0)-(10,12))
        │   ├── value:
        │   │   @ CallNode (location: (10,0)-(10,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (10,0)-(10,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ XStringNode (location: (10,7)-(10,12))
        │   │   ├── opening_loc: (10,7)-(10,8) = "`"
        │   │   ├── content_loc: (10,8)-(10,11) = "foo"
        │   │   ├── closing_loc: (10,11)-(10,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (10,4)-(10,6) = "=>"
        ├── @ MatchRequiredNode (location: (11,0)-(11,14))
        │   ├── value:
        │   │   @ CallNode (location: (11,0)-(11,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ XStringNode (location: (11,7)-(11,14))
        │   │   ├── opening_loc: (11,7)-(11,10) = "%x["
        │   │   ├── content_loc: (11,10)-(11,13) = "foo"
        │   │   ├── closing_loc: (11,13)-(11,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (11,4)-(11,6) = "=>"
        ├── @ MatchRequiredNode (location: (12,0)-(12,14))
        │   ├── value:
        │   │   @ CallNode (location: (12,0)-(12,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,0)-(12,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (12,7)-(12,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (12,10)-(12,13))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (12,10)-(12,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (12,7)-(12,10) = "%i["
        │   │   ├── closing_loc: (12,13)-(12,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (12,4)-(12,6) = "=>"
        ├── @ MatchRequiredNode (location: (13,0)-(13,14))
        │   ├── value:
        │   │   @ CallNode (location: (13,0)-(13,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (13,7)-(13,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (13,10)-(13,13))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (13,10)-(13,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (13,7)-(13,10) = "%I["
        │   │   ├── closing_loc: (13,13)-(13,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (13,4)-(13,6) = "=>"
        ├── @ MatchRequiredNode (location: (14,0)-(14,14))
        │   ├── value:
        │   │   @ CallNode (location: (14,0)-(14,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (14,7)-(14,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (14,10)-(14,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (14,10)-(14,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (14,7)-(14,10) = "%w["
        │   │   ├── closing_loc: (14,13)-(14,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (14,4)-(14,6) = "=>"
        ├── @ MatchRequiredNode (location: (15,0)-(15,14))
        │   ├── value:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (15,7)-(15,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (15,10)-(15,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (15,10)-(15,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (15,7)-(15,10) = "%W["
        │   │   ├── closing_loc: (15,13)-(15,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (15,4)-(15,6) = "=>"
        ├── @ MatchRequiredNode (location: (16,0)-(16,14))
        │   ├── value:
        │   │   @ CallNode (location: (16,0)-(16,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (16,0)-(16,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (16,7)-(16,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (16,7)-(16,10) = "%q["
        │   │   ├── content_loc: (16,10)-(16,13) = "foo"
        │   │   ├── closing_loc: (16,13)-(16,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (16,4)-(16,6) = "=>"
        ├── @ MatchRequiredNode (location: (17,0)-(17,14))
        │   ├── value:
        │   │   @ CallNode (location: (17,0)-(17,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (17,7)-(17,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (17,7)-(17,10) = "%Q["
        │   │   ├── content_loc: (17,10)-(17,13) = "foo"
        │   │   ├── closing_loc: (17,13)-(17,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (17,4)-(17,6) = "=>"
        ├── @ MatchRequiredNode (location: (18,0)-(18,12))
        │   ├── value:
        │   │   @ CallNode (location: (18,0)-(18,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,0)-(18,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (18,7)-(18,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (18,7)-(18,8) = "\""
        │   │   ├── content_loc: (18,8)-(18,11) = "foo"
        │   │   ├── closing_loc: (18,11)-(18,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (18,4)-(18,6) = "=>"
        ├── @ MatchRequiredNode (location: (19,0)-(19,10))
        │   ├── value:
        │   │   @ CallNode (location: (19,0)-(19,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ NilNode (location: (19,7)-(19,10))
        │   └── operator_loc: (19,4)-(19,6) = "=>"
        ├── @ MatchRequiredNode (location: (20,0)-(20,11))
        │   ├── value:
        │   │   @ CallNode (location: (20,0)-(20,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SelfNode (location: (20,7)-(20,11))
        │   └── operator_loc: (20,4)-(20,6) = "=>"
        ├── @ MatchRequiredNode (location: (21,0)-(21,11))
        │   ├── value:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ TrueNode (location: (21,7)-(21,11))
        │   └── operator_loc: (21,4)-(21,6) = "=>"
        ├── @ MatchRequiredNode (location: (22,0)-(22,12))
        │   ├── value:
        │   │   @ CallNode (location: (22,0)-(22,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (22,0)-(22,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FalseNode (location: (22,7)-(22,12))
        │   └── operator_loc: (22,4)-(22,6) = "=>"
        ├── @ MatchRequiredNode (location: (23,0)-(23,15))
        │   ├── value:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (23,7)-(23,15))
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (23,4)-(23,6) = "=>"
        ├── @ MatchRequiredNode (location: (24,0)-(24,15))
        │   ├── value:
        │   │   @ CallNode (location: (24,0)-(24,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (24,0)-(24,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (24,7)-(24,15))
        │   └── operator_loc: (24,4)-(24,6) = "=>"
        ├── @ MatchRequiredNode (location: (25,0)-(25,19))
        │   ├── value:
        │   │   @ CallNode (location: (25,0)-(25,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,0)-(25,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (25,7)-(25,19))
        │   └── operator_loc: (25,4)-(25,6) = "=>"
        ├── @ MatchRequiredNode (location: (26,0)-(26,17))
        │   ├── value:
        │   │   @ CallNode (location: (26,0)-(26,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,0)-(26,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ LambdaNode (location: (26,7)-(26,17))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (26,7)-(26,9) = "->"
        │   │   ├── opening_loc: (26,10)-(26,11) = "{"
        │   │   ├── closing_loc: (26,16)-(26,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (26,12)-(26,15))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (26,12)-(26,15))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (26,4)-(26,6) = "=>"
        ├── @ MatchRequiredNode (location: (28,0)-(28,13))
        │   ├── value:
        │   │   @ CallNode (location: (28,0)-(28,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,0)-(28,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (28,7)-(28,13))
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (28,7)-(28,8))
        │   │   │   └── flags: decimal
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (28,12)-(28,13))
        │   │   │   └── flags: decimal
        │   │   ├── operator_loc: (28,9)-(28,11) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (28,4)-(28,6) = "=>"
        ├── @ MatchRequiredNode (location: (29,0)-(29,17))
        │   ├── value:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (29,7)-(29,17))
        │   │   ├── left:
        │   │   │   @ FloatNode (location: (29,7)-(29,10))
        │   │   ├── right:
        │   │   │   @ FloatNode (location: (29,14)-(29,17))
        │   │   ├── operator_loc: (29,11)-(29,13) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (29,4)-(29,6) = "=>"
        ├── @ MatchRequiredNode (location: (30,0)-(30,15))
        │   ├── value:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (30,7)-(30,15))
        │   │   ├── left:
        │   │   │   @ ImaginaryNode (location: (30,7)-(30,9))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,7)-(30,8))
        │   │   │       └── flags: decimal
        │   │   ├── right:
        │   │   │   @ ImaginaryNode (location: (30,13)-(30,15))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,13)-(30,14))
        │   │   │       └── flags: decimal
        │   │   ├── operator_loc: (30,10)-(30,12) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (30,4)-(30,6) = "=>"
        ├── @ MatchRequiredNode (location: (31,0)-(31,15))
        │   ├── value:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (31,7)-(31,15))
        │   │   ├── left:
        │   │   │   @ RationalNode (location: (31,7)-(31,9))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (31,7)-(31,8))
        │   │   │       └── flags: decimal
        │   │   ├── right:
        │   │   │   @ RationalNode (location: (31,13)-(31,15))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (31,13)-(31,14))
        │   │   │       └── flags: decimal
        │   │   ├── operator_loc: (31,10)-(31,12) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (31,4)-(31,6) = "=>"
        ├── @ MatchRequiredNode (location: (32,0)-(32,19))
        │   ├── value:
        │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (32,7)-(32,19))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (32,7)-(32,11))
        │   │   │   ├── opening_loc: (32,7)-(32,8) = ":"
        │   │   │   ├── value_loc: (32,8)-(32,11) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (32,15)-(32,19))
        │   │   │   ├── opening_loc: (32,15)-(32,16) = ":"
        │   │   │   ├── value_loc: (32,16)-(32,19) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (32,12)-(32,14) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (32,4)-(32,6) = "=>"
        ├── @ MatchRequiredNode (location: (33,0)-(33,25))
        │   ├── value:
        │   │   @ CallNode (location: (33,0)-(33,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (33,7)-(33,25))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (33,7)-(33,14))
        │   │   │   ├── opening_loc: (33,7)-(33,10) = "%s["
        │   │   │   ├── value_loc: (33,10)-(33,13) = "foo"
        │   │   │   ├── closing_loc: (33,13)-(33,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (33,18)-(33,25))
        │   │   │   ├── opening_loc: (33,18)-(33,21) = "%s["
        │   │   │   ├── value_loc: (33,21)-(33,24) = "foo"
        │   │   │   ├── closing_loc: (33,24)-(33,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (33,15)-(33,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (33,4)-(33,6) = "=>"
        ├── @ MatchRequiredNode (location: (34,0)-(34,23))
        │   ├── value:
        │   │   @ CallNode (location: (34,0)-(34,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,0)-(34,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (34,7)-(34,23))
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (34,7)-(34,13))
        │   │   │   ├── opening_loc: (34,7)-(34,9) = ":\""
        │   │   │   ├── value_loc: (34,9)-(34,12) = "foo"
        │   │   │   ├── closing_loc: (34,12)-(34,13) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (34,17)-(34,23))
        │   │   │   ├── opening_loc: (34,17)-(34,19) = ":\""
        │   │   │   ├── value_loc: (34,19)-(34,22) = "foo"
        │   │   │   ├── closing_loc: (34,22)-(34,23) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (34,14)-(34,16) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (34,4)-(34,6) = "=>"
        ├── @ MatchRequiredNode (location: (35,0)-(35,21))
        │   ├── value:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (35,7)-(35,21))
        │   │   ├── left:
        │   │   │   @ RegularExpressionNode (location: (35,7)-(35,12))
        │   │   │   ├── opening_loc: (35,7)-(35,8) = "/"
        │   │   │   ├── content_loc: (35,8)-(35,11) = "foo"
        │   │   │   ├── closing_loc: (35,11)-(35,12) = "/"
        │   │   │   ├── unescaped: "foo"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ RegularExpressionNode (location: (35,16)-(35,21))
        │   │   │   ├── opening_loc: (35,16)-(35,17) = "/"
        │   │   │   ├── content_loc: (35,17)-(35,20) = "foo"
        │   │   │   ├── closing_loc: (35,20)-(35,21) = "/"
        │   │   │   ├── unescaped: "foo"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (35,13)-(35,15) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (35,4)-(35,6) = "=>"
        ├── @ MatchRequiredNode (location: (36,0)-(36,21))
        │   ├── value:
        │   │   @ CallNode (location: (36,0)-(36,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (36,0)-(36,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (36,7)-(36,21))
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (36,7)-(36,12))
        │   │   │   ├── opening_loc: (36,7)-(36,8) = "`"
        │   │   │   ├── content_loc: (36,8)-(36,11) = "foo"
        │   │   │   ├── closing_loc: (36,11)-(36,12) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (36,16)-(36,21))
        │   │   │   ├── opening_loc: (36,16)-(36,17) = "`"
        │   │   │   ├── content_loc: (36,17)-(36,20) = "foo"
        │   │   │   ├── closing_loc: (36,20)-(36,21) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (36,13)-(36,15) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (36,4)-(36,6) = "=>"
        ├── @ MatchRequiredNode (location: (37,0)-(37,25))
        │   ├── value:
        │   │   @ CallNode (location: (37,0)-(37,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,0)-(37,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (37,7)-(37,25))
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (37,7)-(37,14))
        │   │   │   ├── opening_loc: (37,7)-(37,10) = "%x["
        │   │   │   ├── content_loc: (37,10)-(37,13) = "foo"
        │   │   │   ├── closing_loc: (37,13)-(37,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (37,18)-(37,25))
        │   │   │   ├── opening_loc: (37,18)-(37,21) = "%x["
        │   │   │   ├── content_loc: (37,21)-(37,24) = "foo"
        │   │   │   ├── closing_loc: (37,24)-(37,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (37,15)-(37,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (37,4)-(37,6) = "=>"
        ├── @ MatchRequiredNode (location: (38,0)-(38,25))
        │   ├── value:
        │   │   @ CallNode (location: (38,0)-(38,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,0)-(38,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (38,7)-(38,25))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (38,7)-(38,14))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,10)-(38,13))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,10)-(38,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,7)-(38,10) = "%i["
        │   │   │   ├── closing_loc: (38,13)-(38,14) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (38,18)-(38,25))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,21)-(38,24))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,21)-(38,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,18)-(38,21) = "%i["
        │   │   │   ├── closing_loc: (38,24)-(38,25) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (38,15)-(38,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (38,4)-(38,6) = "=>"
        ├── @ MatchRequiredNode (location: (39,0)-(39,25))
        │   ├── value:
        │   │   @ CallNode (location: (39,0)-(39,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (39,0)-(39,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (39,7)-(39,25))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (39,7)-(39,14))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,10)-(39,13))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,10)-(39,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,7)-(39,10) = "%I["
        │   │   │   ├── closing_loc: (39,13)-(39,14) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (39,18)-(39,25))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,21)-(39,24))
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,21)-(39,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,18)-(39,21) = "%I["
        │   │   │   ├── closing_loc: (39,24)-(39,25) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (39,15)-(39,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (39,4)-(39,6) = "=>"
        ├── @ MatchRequiredNode (location: (40,0)-(40,25))
        │   ├── value:
        │   │   @ CallNode (location: (40,0)-(40,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (40,0)-(40,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (40,7)-(40,25))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (40,7)-(40,14))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,10)-(40,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,10)-(40,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,7)-(40,10) = "%w["
        │   │   │   ├── closing_loc: (40,13)-(40,14) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (40,18)-(40,25))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,21)-(40,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,21)-(40,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,18)-(40,21) = "%w["
        │   │   │   ├── closing_loc: (40,24)-(40,25) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (40,15)-(40,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (40,4)-(40,6) = "=>"
        ├── @ MatchRequiredNode (location: (41,0)-(41,25))
        │   ├── value:
        │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (41,7)-(41,25))
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (41,7)-(41,14))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,10)-(41,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,10)-(41,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,7)-(41,10) = "%W["
        │   │   │   ├── closing_loc: (41,13)-(41,14) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (41,18)-(41,25))
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,21)-(41,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,21)-(41,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,18)-(41,21) = "%W["
        │   │   │   ├── closing_loc: (41,24)-(41,25) = "]"
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (41,15)-(41,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (41,4)-(41,6) = "=>"
        ├── @ MatchRequiredNode (location: (42,0)-(42,25))
        │   ├── value:
        │   │   @ CallNode (location: (42,0)-(42,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (42,0)-(42,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (42,7)-(42,25))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (42,7)-(42,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,7)-(42,10) = "%q["
        │   │   │   ├── content_loc: (42,10)-(42,13) = "foo"
        │   │   │   ├── closing_loc: (42,13)-(42,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (42,18)-(42,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,18)-(42,21) = "%q["
        │   │   │   ├── content_loc: (42,21)-(42,24) = "foo"
        │   │   │   ├── closing_loc: (42,24)-(42,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (42,15)-(42,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (42,4)-(42,6) = "=>"
        ├── @ MatchRequiredNode (location: (43,0)-(43,25))
        │   ├── value:
        │   │   @ CallNode (location: (43,0)-(43,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (43,0)-(43,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (43,7)-(43,25))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (43,7)-(43,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,7)-(43,10) = "%Q["
        │   │   │   ├── content_loc: (43,10)-(43,13) = "foo"
        │   │   │   ├── closing_loc: (43,13)-(43,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (43,18)-(43,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,18)-(43,21) = "%Q["
        │   │   │   ├── content_loc: (43,21)-(43,24) = "foo"
        │   │   │   ├── closing_loc: (43,24)-(43,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (43,15)-(43,17) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (43,4)-(43,6) = "=>"
        ├── @ MatchRequiredNode (location: (44,0)-(44,21))
        │   ├── value:
        │   │   @ CallNode (location: (44,0)-(44,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,0)-(44,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (44,7)-(44,21))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (44,7)-(44,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,7)-(44,8) = "\""
        │   │   │   ├── content_loc: (44,8)-(44,11) = "foo"
        │   │   │   ├── closing_loc: (44,11)-(44,12) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (44,16)-(44,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,16)-(44,17) = "\""
        │   │   │   ├── content_loc: (44,17)-(44,20) = "foo"
        │   │   │   ├── closing_loc: (44,20)-(44,21) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── operator_loc: (44,13)-(44,15) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (44,4)-(44,6) = "=>"
        ├── @ MatchRequiredNode (location: (45,0)-(45,17))
        │   ├── value:
        │   │   @ CallNode (location: (45,0)-(45,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (45,0)-(45,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (45,7)-(45,17))
        │   │   ├── left:
        │   │   │   @ NilNode (location: (45,7)-(45,10))
        │   │   ├── right:
        │   │   │   @ NilNode (location: (45,14)-(45,17))
        │   │   ├── operator_loc: (45,11)-(45,13) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (45,4)-(45,6) = "=>"
        ├── @ MatchRequiredNode (location: (46,0)-(46,19))
        │   ├── value:
        │   │   @ CallNode (location: (46,0)-(46,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (46,0)-(46,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (46,7)-(46,19))
        │   │   ├── left:
        │   │   │   @ SelfNode (location: (46,7)-(46,11))
        │   │   ├── right:
        │   │   │   @ SelfNode (location: (46,15)-(46,19))
        │   │   ├── operator_loc: (46,12)-(46,14) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (46,4)-(46,6) = "=>"
        ├── @ MatchRequiredNode (location: (47,0)-(47,19))
        │   ├── value:
        │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (47,7)-(47,19))
        │   │   ├── left:
        │   │   │   @ TrueNode (location: (47,7)-(47,11))
        │   │   ├── right:
        │   │   │   @ TrueNode (location: (47,15)-(47,19))
        │   │   ├── operator_loc: (47,12)-(47,14) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (47,4)-(47,6) = "=>"
        ├── @ MatchRequiredNode (location: (48,0)-(48,21))
        │   ├── value:
        │   │   @ CallNode (location: (48,0)-(48,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (48,7)-(48,21))
        │   │   ├── left:
        │   │   │   @ FalseNode (location: (48,7)-(48,12))
        │   │   ├── right:
        │   │   │   @ FalseNode (location: (48,16)-(48,21))
        │   │   ├── operator_loc: (48,13)-(48,15) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (48,4)-(48,6) = "=>"
        ├── @ MatchRequiredNode (location: (49,0)-(49,27))
        │   ├── value:
        │   │   @ CallNode (location: (49,0)-(49,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (49,0)-(49,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (49,7)-(49,27))
        │   │   ├── left:
        │   │   │   @ SourceFileNode (location: (49,7)-(49,15))
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── right:
        │   │   │   @ SourceFileNode (location: (49,19)-(49,27))
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── operator_loc: (49,16)-(49,18) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (49,4)-(49,6) = "=>"
        ├── @ MatchRequiredNode (location: (50,0)-(50,27))
        │   ├── value:
        │   │   @ CallNode (location: (50,0)-(50,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (50,0)-(50,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (50,7)-(50,27))
        │   │   ├── left:
        │   │   │   @ SourceLineNode (location: (50,7)-(50,15))
        │   │   ├── right:
        │   │   │   @ SourceLineNode (location: (50,19)-(50,27))
        │   │   ├── operator_loc: (50,16)-(50,18) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (50,4)-(50,6) = "=>"
        ├── @ MatchRequiredNode (location: (51,0)-(51,35))
        │   ├── value:
        │   │   @ CallNode (location: (51,0)-(51,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (51,0)-(51,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (51,7)-(51,35))
        │   │   ├── left:
        │   │   │   @ SourceEncodingNode (location: (51,7)-(51,19))
        │   │   ├── right:
        │   │   │   @ SourceEncodingNode (location: (51,23)-(51,35))
        │   │   ├── operator_loc: (51,20)-(51,22) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (51,4)-(51,6) = "=>"
        ├── @ MatchRequiredNode (location: (52,0)-(52,31))
        │   ├── value:
        │   │   @ CallNode (location: (52,0)-(52,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (52,0)-(52,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RangeNode (location: (52,7)-(52,31))
        │   │   ├── left:
        │   │   │   @ LambdaNode (location: (52,7)-(52,17))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,7)-(52,9) = "->"
        │   │   │   ├── opening_loc: (52,10)-(52,11) = "{"
        │   │   │   ├── closing_loc: (52,16)-(52,17) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,12)-(52,15))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,12)-(52,15))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── right:
        │   │   │   @ LambdaNode (location: (52,21)-(52,31))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,21)-(52,23) = "->"
        │   │   │   ├── opening_loc: (52,24)-(52,25) = "{"
        │   │   │   ├── closing_loc: (52,30)-(52,31) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,26)-(52,29))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,26)-(52,29))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── operator_loc: (52,18)-(52,20) = ".."
        │   │   └── flags: ∅
        │   └── operator_loc: (52,4)-(52,6) = "=>"
        ├── @ MatchRequiredNode (location: (54,0)-(54,11))
        │   ├── value:
        │   │   @ CallNode (location: (54,0)-(54,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (54,0)-(54,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (54,7)-(54,11))
        │   │   ├── variable:
        │   │   │   @ LocalVariableReadNode (location: (54,8)-(54,11))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (54,7)-(54,8) = "^"
        │   └── operator_loc: (54,4)-(54,6) = "=>"
        ├── @ MatchRequiredNode (location: (55,0)-(55,12))
        │   ├── value:
        │   │   @ CallNode (location: (55,0)-(55,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (55,0)-(55,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (55,7)-(55,12))
        │   │   ├── variable:
        │   │   │   @ InstanceVariableReadNode (location: (55,8)-(55,12))
        │   │   │   └── name: :@bar
        │   │   └── operator_loc: (55,7)-(55,8) = "^"
        │   └── operator_loc: (55,4)-(55,6) = "=>"
        ├── @ MatchRequiredNode (location: (56,0)-(56,13))
        │   ├── value:
        │   │   @ CallNode (location: (56,0)-(56,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (56,0)-(56,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (56,7)-(56,13))
        │   │   ├── variable:
        │   │   │   @ ClassVariableReadNode (location: (56,8)-(56,13))
        │   │   │   └── name: :@@bar
        │   │   └── operator_loc: (56,7)-(56,8) = "^"
        │   └── operator_loc: (56,4)-(56,6) = "=>"
        ├── @ MatchRequiredNode (location: (57,0)-(57,12))
        │   ├── value:
        │   │   @ CallNode (location: (57,0)-(57,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (57,0)-(57,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (57,7)-(57,12))
        │   │   ├── variable:
        │   │   │   @ GlobalVariableReadNode (location: (57,8)-(57,12))
        │   │   │   └── name: :$bar
        │   │   └── operator_loc: (57,7)-(57,8) = "^"
        │   └── operator_loc: (57,4)-(57,6) = "=>"
        ├── @ MatchRequiredNode (location: (59,0)-(59,11))
        │   ├── value:
        │   │   @ CallNode (location: (59,0)-(59,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (59,0)-(59,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (59,7)-(59,11))
        │   │   ├── expression:
        │   │   │   @ IntegerNode (location: (59,9)-(59,10))
        │   │   │   └── flags: decimal
        │   │   ├── operator_loc: (59,7)-(59,8) = "^"
        │   │   ├── lparen_loc: (59,8)-(59,9) = "("
        │   │   └── rparen_loc: (59,10)-(59,11) = ")"
        │   └── operator_loc: (59,4)-(59,6) = "=>"
        ├── @ MatchRequiredNode (location: (60,0)-(60,13))
        │   ├── value:
        │   │   @ CallNode (location: (60,0)-(60,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (60,7)-(60,13))
        │   │   ├── expression:
        │   │   │   @ NilNode (location: (60,9)-(60,12))
        │   │   ├── operator_loc: (60,7)-(60,8) = "^"
        │   │   ├── lparen_loc: (60,8)-(60,9) = "("
        │   │   └── rparen_loc: (60,12)-(60,13) = ")"
        │   └── operator_loc: (60,4)-(60,6) = "=>"
        ├── @ MatchRequiredNode (location: (61,0)-(61,23))
        │   ├── value:
        │   │   @ CallNode (location: (61,0)-(61,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (61,0)-(61,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (61,7)-(61,23))
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (61,9)-(61,22))
        │   │   │   ├── receiver:
        │   │   │   │   @ StringNode (location: (61,9)-(61,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (61,9)-(61,10) = "\""
        │   │   │   │   ├── content_loc: (61,10)-(61,13) = "bar"
        │   │   │   │   ├── closing_loc: (61,13)-(61,14) = "\""
        │   │   │   │   └── unescaped: "bar"
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :+
        │   │   │   ├── message_loc: (61,15)-(61,16) = "+"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (61,17)-(61,22))
        │   │   │   │   ├── arguments: (length: 1)
        │   │   │   │   │   └── @ StringNode (location: (61,17)-(61,22))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       ├── opening_loc: (61,17)-(61,18) = "\""
        │   │   │   │   │       ├── content_loc: (61,18)-(61,21) = "baz"
        │   │   │   │   │       ├── closing_loc: (61,21)-(61,22) = "\""
        │   │   │   │   │       └── unescaped: "baz"
        │   │   │   │   └── flags: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   └── flags: ∅
        │   │   ├── operator_loc: (61,7)-(61,8) = "^"
        │   │   ├── lparen_loc: (61,8)-(61,9) = "("
        │   │   └── rparen_loc: (61,22)-(61,23) = ")"
        │   └── operator_loc: (61,4)-(61,6) = "=>"
        ├── @ MatchRequiredNode (location: (63,0)-(63,10))
        │   ├── value:
        │   │   @ CallNode (location: (63,0)-(63,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (63,0)-(63,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ConstantReadNode (location: (63,7)-(63,10))
        │   │   └── name: :Foo
        │   └── operator_loc: (63,4)-(63,6) = "=>"
        ├── @ MatchRequiredNode (location: (64,0)-(64,20))
        │   ├── value:
        │   │   @ CallNode (location: (64,0)-(64,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (64,7)-(64,20))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (64,7)-(64,15))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (64,7)-(64,10))
        │   │   │   │   └── name: :Foo
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (64,12)-(64,15))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (64,10)-(64,12) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (64,17)-(64,20))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (64,15)-(64,17) = "::"
        │   └── operator_loc: (64,4)-(64,6) = "=>"
        ├── @ MatchRequiredNode (location: (65,0)-(65,12))
        │   ├── value:
        │   │   @ CallNode (location: (65,0)-(65,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (65,0)-(65,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (65,7)-(65,12))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (65,9)-(65,12))
        │   │   │   └── name: :Foo
        │   │   └── delimiter_loc: (65,7)-(65,9) = "::"
        │   └── operator_loc: (65,4)-(65,6) = "=>"
        ├── @ MatchRequiredNode (location: (66,0)-(66,22))
        │   ├── value:
        │   │   @ CallNode (location: (66,0)-(66,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (66,0)-(66,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (66,7)-(66,22))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (66,7)-(66,17))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantPathNode (location: (66,7)-(66,12))
        │   │   │   │   ├── parent: ∅
        │   │   │   │   ├── child:
        │   │   │   │   │   @ ConstantReadNode (location: (66,9)-(66,12))
        │   │   │   │   │   └── name: :Foo
        │   │   │   │   └── delimiter_loc: (66,7)-(66,9) = "::"
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (66,14)-(66,17))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (66,12)-(66,14) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (66,19)-(66,22))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (66,17)-(66,19) = "::"
        │   └── operator_loc: (66,4)-(66,6) = "=>"
        ├── @ MatchRequiredNode (location: (68,0)-(68,12))
        │   ├── value:
        │   │   @ CallNode (location: (68,0)-(68,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (68,0)-(68,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (68,7)-(68,12))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (68,7)-(68,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (68,10)-(68,11) = "("
        │   │   └── closing_loc: (68,11)-(68,12) = ")"
        │   └── operator_loc: (68,4)-(68,6) = "=>"
        ├── @ MatchRequiredNode (location: (69,0)-(69,13))
        │   ├── value:
        │   │   @ CallNode (location: (69,0)-(69,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (69,0)-(69,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (69,7)-(69,13))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (69,7)-(69,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (69,11)-(69,12))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (69,10)-(69,11) = "("
        │   │   └── closing_loc: (69,12)-(69,13) = ")"
        │   └── operator_loc: (69,4)-(69,6) = "=>"
        ├── @ MatchRequiredNode (location: (70,0)-(70,19))
        │   ├── value:
        │   │   @ CallNode (location: (70,0)-(70,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (70,0)-(70,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (70,7)-(70,19))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (70,7)-(70,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (70,11)-(70,12))
        │   │   │   │   └── flags: decimal
        │   │   │   ├── @ IntegerNode (location: (70,14)-(70,15))
        │   │   │   │   └── flags: decimal
        │   │   │   └── @ IntegerNode (location: (70,17)-(70,18))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (70,10)-(70,11) = "("
        │   │   └── closing_loc: (70,18)-(70,19) = ")"
        │   └── operator_loc: (70,4)-(70,6) = "=>"
        ├── @ MatchRequiredNode (location: (71,0)-(71,15))
        │   ├── value:
        │   │   @ CallNode (location: (71,0)-(71,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (71,0)-(71,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (71,7)-(71,15))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (71,7)-(71,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (71,11)-(71,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (71,10)-(71,11) = "("
        │   │   └── closing_loc: (71,14)-(71,15) = ")"
        │   └── operator_loc: (71,4)-(71,6) = "=>"
        ├── @ MatchRequiredNode (location: (72,0)-(72,21))
        │   ├── value:
        │   │   @ CallNode (location: (72,0)-(72,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (72,7)-(72,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (72,7)-(72,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (72,11)-(72,15))
        │   │   │   ├── operator_loc: (72,11)-(72,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (72,12)-(72,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (72,17)-(72,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (72,10)-(72,11) = "("
        │   │   └── closing_loc: (72,20)-(72,21) = ")"
        │   └── operator_loc: (72,4)-(72,6) = "=>"
        ├── @ MatchRequiredNode (location: (73,0)-(73,21))
        │   ├── value:
        │   │   @ CallNode (location: (73,0)-(73,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (73,0)-(73,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (73,7)-(73,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (73,7)-(73,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (73,11)-(73,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (73,16)-(73,20))
        │   │   │   ├── operator_loc: (73,16)-(73,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (73,17)-(73,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (73,10)-(73,11) = "("
        │   │   └── closing_loc: (73,20)-(73,21) = ")"
        │   └── operator_loc: (73,4)-(73,6) = "=>"
        ├── @ MatchRequiredNode (location: (74,0)-(74,27))
        │   ├── value:
        │   │   @ CallNode (location: (74,0)-(74,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (74,0)-(74,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (74,7)-(74,27))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (74,7)-(74,10))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (74,11)-(74,15))
        │   │   │   ├── operator_loc: (74,11)-(74,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,12)-(74,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (74,17)-(74,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (74,22)-(74,26))
        │   │   │   ├── operator_loc: (74,22)-(74,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,23)-(74,26))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (74,10)-(74,11) = "("
        │   │   └── closing_loc: (74,26)-(74,27) = ")"
        │   └── operator_loc: (74,4)-(74,6) = "=>"
        ├── @ MatchRequiredNode (location: (76,0)-(76,12))
        │   ├── value:
        │   │   @ CallNode (location: (76,0)-(76,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (76,0)-(76,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (76,7)-(76,12))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (76,7)-(76,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (76,10)-(76,11) = "["
        │   │   └── closing_loc: (76,11)-(76,12) = "]"
        │   └── operator_loc: (76,4)-(76,6) = "=>"
        ├── @ MatchRequiredNode (location: (77,0)-(77,13))
        │   ├── value:
        │   │   @ CallNode (location: (77,0)-(77,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (77,0)-(77,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (77,7)-(77,13))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (77,7)-(77,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (77,11)-(77,12))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (77,10)-(77,11) = "["
        │   │   └── closing_loc: (77,12)-(77,13) = "]"
        │   └── operator_loc: (77,4)-(77,6) = "=>"
        ├── @ MatchRequiredNode (location: (78,0)-(78,19))
        │   ├── value:
        │   │   @ CallNode (location: (78,0)-(78,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (78,0)-(78,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (78,7)-(78,19))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (78,7)-(78,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (78,11)-(78,12))
        │   │   │   │   └── flags: decimal
        │   │   │   ├── @ IntegerNode (location: (78,14)-(78,15))
        │   │   │   │   └── flags: decimal
        │   │   │   └── @ IntegerNode (location: (78,17)-(78,18))
        │   │   │       └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (78,10)-(78,11) = "["
        │   │   └── closing_loc: (78,18)-(78,19) = "]"
        │   └── operator_loc: (78,4)-(78,6) = "=>"
        ├── @ MatchRequiredNode (location: (79,0)-(79,17))
        │   ├── value:
        │   │   @ CallNode (location: (79,0)-(79,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (79,0)-(79,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (79,7)-(79,17))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (79,7)-(79,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (79,11)-(79,16))
        │   │   │       ├── constant:
        │   │   │       │   @ ConstantReadNode (location: (79,11)-(79,14))
        │   │   │       │   └── name: :Foo
        │   │   │       ├── requireds: (length: 0)
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (79,14)-(79,15) = "["
        │   │   │       └── closing_loc: (79,15)-(79,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (79,10)-(79,11) = "["
        │   │   └── closing_loc: (79,16)-(79,17) = "]"
        │   └── operator_loc: (79,4)-(79,6) = "=>"
        ├── @ MatchRequiredNode (location: (80,0)-(80,15))
        │   ├── value:
        │   │   @ CallNode (location: (80,0)-(80,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (80,0)-(80,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (80,7)-(80,15))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (80,7)-(80,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (80,11)-(80,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (80,10)-(80,11) = "["
        │   │   └── closing_loc: (80,14)-(80,15) = "]"
        │   └── operator_loc: (80,4)-(80,6) = "=>"
        ├── @ MatchRequiredNode (location: (81,0)-(81,21))
        │   ├── value:
        │   │   @ CallNode (location: (81,0)-(81,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (81,0)-(81,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (81,7)-(81,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (81,7)-(81,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (81,11)-(81,15))
        │   │   │   ├── operator_loc: (81,11)-(81,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (81,12)-(81,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (81,17)-(81,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (81,10)-(81,11) = "["
        │   │   └── closing_loc: (81,20)-(81,21) = "]"
        │   └── operator_loc: (81,4)-(81,6) = "=>"
        ├── @ MatchRequiredNode (location: (82,0)-(82,21))
        │   ├── value:
        │   │   @ CallNode (location: (82,0)-(82,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (82,0)-(82,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (82,7)-(82,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (82,7)-(82,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (82,11)-(82,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (82,16)-(82,20))
        │   │   │   ├── operator_loc: (82,16)-(82,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (82,17)-(82,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (82,10)-(82,11) = "["
        │   │   └── closing_loc: (82,20)-(82,21) = "]"
        │   └── operator_loc: (82,4)-(82,6) = "=>"
        ├── @ MatchRequiredNode (location: (83,0)-(83,27))
        │   ├── value:
        │   │   @ CallNode (location: (83,0)-(83,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (83,0)-(83,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (83,7)-(83,27))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (83,7)-(83,10))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (83,11)-(83,15))
        │   │   │   ├── operator_loc: (83,11)-(83,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,12)-(83,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (83,17)-(83,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (83,22)-(83,26))
        │   │   │   ├── operator_loc: (83,22)-(83,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,23)-(83,26))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (83,10)-(83,11) = "["
        │   │   └── closing_loc: (83,26)-(83,27) = "]"
        │   └── operator_loc: (83,4)-(83,6) = "=>"
        ├── @ MatchRequiredNode (location: (85,0)-(85,11))
        │   ├── value:
        │   │   @ CallNode (location: (85,0)-(85,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (85,0)-(85,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (85,7)-(85,11))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (85,7)-(85,11))
        │   │   │   ├── operator_loc: (85,7)-(85,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (85,8)-(85,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (85,4)-(85,6) = "=>"
        ├── @ MatchRequiredNode (location: (86,0)-(86,21))
        │   ├── value:
        │   │   @ CallNode (location: (86,0)-(86,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (86,0)-(86,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (86,7)-(86,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (86,7)-(86,11))
        │   │   │   ├── operator_loc: (86,7)-(86,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (86,8)-(86,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (86,13)-(86,16))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (86,18)-(86,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (86,4)-(86,6) = "=>"
        ├── @ MatchRequiredNode (location: (87,0)-(87,21))
        │   ├── value:
        │   │   @ CallNode (location: (87,0)-(87,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (87,0)-(87,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (87,7)-(87,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,7)-(87,10))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (87,12)-(87,16))
        │   │   │   ├── operator_loc: (87,12)-(87,13) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (87,13)-(87,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,18)-(87,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (87,4)-(87,6) = "=>"
        ├── @ MatchRequiredNode (location: (88,0)-(88,21))
        │   ├── value:
        │   │   @ CallNode (location: (88,0)-(88,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (88,0)-(88,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (88,7)-(88,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (88,7)-(88,10))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (88,12)-(88,15))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (88,17)-(88,21))
        │   │   │   ├── operator_loc: (88,17)-(88,18) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (88,18)-(88,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (88,4)-(88,6) = "=>"
        ├── @ MatchRequiredNode (location: (89,0)-(89,22))
        │   ├── value:
        │   │   @ CallNode (location: (89,0)-(89,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (89,0)-(89,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (89,7)-(89,22))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (89,7)-(89,11))
        │   │   │   ├── operator_loc: (89,7)-(89,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,8)-(89,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (89,13)-(89,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (89,18)-(89,22))
        │   │   │   ├── operator_loc: (89,18)-(89,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,19)-(89,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (89,4)-(89,6) = "=>"
        ├── @ MatchRequiredNode (location: (91,0)-(91,9))
        │   ├── value:
        │   │   @ CallNode (location: (91,0)-(91,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (91,0)-(91,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (91,7)-(91,9))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (91,7)-(91,8) = "["
        │   │   └── closing_loc: (91,8)-(91,9) = "]"
        │   └── operator_loc: (91,4)-(91,6) = "=>"
        ├── @ MatchRequiredNode (location: (92,0)-(92,17))
        │   ├── value:
        │   │   @ CallNode (location: (92,0)-(92,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (92,0)-(92,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (92,7)-(92,17))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (92,8)-(92,16))
        │   │   │       ├── constant: ∅
        │   │   │       ├── requireds: (length: 1)
        │   │   │       │   └── @ ArrayPatternNode (location: (92,9)-(92,15))
        │   │   │       │       ├── constant: ∅
        │   │   │       │       ├── requireds: (length: 1)
        │   │   │       │       │   └── @ ArrayPatternNode (location: (92,10)-(92,14))
        │   │   │       │       │       ├── constant: ∅
        │   │   │       │       │       ├── requireds: (length: 1)
        │   │   │       │       │       │   └── @ ArrayPatternNode (location: (92,11)-(92,13))
        │   │   │       │       │       │       ├── constant: ∅
        │   │   │       │       │       │       ├── requireds: (length: 0)
        │   │   │       │       │       │       ├── rest: ∅
        │   │   │       │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       │       ├── opening_loc: (92,11)-(92,12) = "["
        │   │   │       │       │       │       └── closing_loc: (92,12)-(92,13) = "]"
        │   │   │       │       │       ├── rest: ∅
        │   │   │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       ├── opening_loc: (92,10)-(92,11) = "["
        │   │   │       │       │       └── closing_loc: (92,13)-(92,14) = "]"
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── posts: (length: 0)
        │   │   │       │       ├── opening_loc: (92,9)-(92,10) = "["
        │   │   │       │       └── closing_loc: (92,14)-(92,15) = "]"
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (92,8)-(92,9) = "["
        │   │   │       └── closing_loc: (92,15)-(92,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (92,7)-(92,8) = "["
        │   │   └── closing_loc: (92,16)-(92,17) = "]"
        │   └── operator_loc: (92,4)-(92,6) = "=>"
        ├── @ MatchRequiredNode (location: (94,0)-(94,13))
        │   ├── value:
        │   │   @ CallNode (location: (94,0)-(94,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (94,0)-(94,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (94,7)-(94,13))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (94,8)-(94,12))
        │   │   │   ├── operator_loc: (94,8)-(94,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (94,9)-(94,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (94,7)-(94,8) = "["
        │   │   └── closing_loc: (94,12)-(94,13) = "]"
        │   └── operator_loc: (94,4)-(94,6) = "=>"
        ├── @ MatchRequiredNode (location: (95,0)-(95,23))
        │   ├── value:
        │   │   @ CallNode (location: (95,0)-(95,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (95,0)-(95,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (95,7)-(95,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (95,8)-(95,12))
        │   │   │   ├── operator_loc: (95,8)-(95,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (95,9)-(95,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (95,14)-(95,17))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (95,19)-(95,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (95,7)-(95,8) = "["
        │   │   └── closing_loc: (95,22)-(95,23) = "]"
        │   └── operator_loc: (95,4)-(95,6) = "=>"
        ├── @ MatchRequiredNode (location: (96,0)-(96,23))
        │   ├── value:
        │   │   @ CallNode (location: (96,0)-(96,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (96,0)-(96,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (96,7)-(96,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (96,8)-(96,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (96,13)-(96,17))
        │   │   │   ├── operator_loc: (96,13)-(96,14) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (96,14)-(96,17))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (96,19)-(96,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (96,7)-(96,8) = "["
        │   │   └── closing_loc: (96,22)-(96,23) = "]"
        │   └── operator_loc: (96,4)-(96,6) = "=>"
        ├── @ MatchRequiredNode (location: (97,0)-(97,23))
        │   ├── value:
        │   │   @ CallNode (location: (97,0)-(97,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (97,0)-(97,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (97,7)-(97,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (97,8)-(97,11))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (97,13)-(97,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (97,18)-(97,22))
        │   │   │   ├── operator_loc: (97,18)-(97,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (97,19)-(97,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (97,7)-(97,8) = "["
        │   │   └── closing_loc: (97,22)-(97,23) = "]"
        │   └── operator_loc: (97,4)-(97,6) = "=>"
        ├── @ MatchRequiredNode (location: (98,0)-(98,24))
        │   ├── value:
        │   │   @ CallNode (location: (98,0)-(98,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (98,0)-(98,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (98,7)-(98,24))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (98,8)-(98,12))
        │   │   │   ├── operator_loc: (98,8)-(98,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (98,9)-(98,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (98,14)-(98,17))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (98,19)-(98,23))
        │   │   │   ├── operator_loc: (98,19)-(98,20) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (98,20)-(98,23))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (98,7)-(98,8) = "["
        │   │   └── closing_loc: (98,23)-(98,24) = "]"
        │   └── operator_loc: (98,4)-(98,6) = "=>"
        ├── @ MatchPredicateNode (location: (100,0)-(100,10))
        │   ├── value:
        │   │   @ CallNode (location: (100,0)-(100,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (100,0)-(100,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (100,7)-(100,10))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (100,4)-(100,6) = "in"
        ├── @ MatchPredicateNode (location: (101,0)-(101,8))
        │   ├── value:
        │   │   @ CallNode (location: (101,0)-(101,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (101,0)-(101,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ IntegerNode (location: (101,7)-(101,8))
        │   │   └── flags: decimal
        │   └── operator_loc: (101,4)-(101,6) = "in"
        ├── @ MatchPredicateNode (location: (102,0)-(102,10))
        │   ├── value:
        │   │   @ CallNode (location: (102,0)-(102,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (102,0)-(102,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FloatNode (location: (102,7)-(102,10))
        │   └── operator_loc: (102,4)-(102,6) = "in"
        ├── @ MatchPredicateNode (location: (103,0)-(103,9))
        │   ├── value:
        │   │   @ CallNode (location: (103,0)-(103,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (103,0)-(103,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (103,7)-(103,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (103,7)-(103,8))
        │   │       └── flags: decimal
        │   └── operator_loc: (103,4)-(103,6) = "in"
        ├── @ MatchPredicateNode (location: (104,0)-(104,9))
        │   ├── value:
        │   │   @ CallNode (location: (104,0)-(104,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (104,0)-(104,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RationalNode (location: (104,7)-(104,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (104,7)-(104,8))
        │   │       └── flags: decimal
        │   └── operator_loc: (104,4)-(104,6) = "in"
        ├── @ MatchPredicateNode (location: (105,0)-(105,11))
        │   ├── value:
        │   │   @ CallNode (location: (105,0)-(105,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (105,0)-(105,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (105,7)-(105,11))
        │   │   ├── opening_loc: (105,7)-(105,8) = ":"
        │   │   ├── value_loc: (105,8)-(105,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (105,4)-(105,6) = "in"
        ├── @ MatchPredicateNode (location: (106,0)-(106,14))
        │   ├── value:
        │   │   @ CallNode (location: (106,0)-(106,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (106,0)-(106,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (106,7)-(106,14))
        │   │   ├── opening_loc: (106,7)-(106,10) = "%s["
        │   │   ├── value_loc: (106,10)-(106,13) = "foo"
        │   │   ├── closing_loc: (106,13)-(106,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (106,4)-(106,6) = "in"
        ├── @ MatchPredicateNode (location: (107,0)-(107,13))
        │   ├── value:
        │   │   @ CallNode (location: (107,0)-(107,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (107,0)-(107,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SymbolNode (location: (107,7)-(107,13))
        │   │   ├── opening_loc: (107,7)-(107,9) = ":\""
        │   │   ├── value_loc: (107,9)-(107,12) = "foo"
        │   │   ├── closing_loc: (107,12)-(107,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (107,4)-(107,6) = "in"
        ├── @ MatchPredicateNode (location: (108,0)-(108,12))
        │   ├── value:
        │   │   @ CallNode (location: (108,0)-(108,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (108,0)-(108,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (108,7)-(108,12))
        │   │   ├── opening_loc: (108,7)-(108,8) = "/"
        │   │   ├── content_loc: (108,8)-(108,11) = "foo"
        │   │   ├── closing_loc: (108,11)-(108,12) = "/"
        │   │   ├── unescaped: "foo"
        │   │   └── flags: ∅
        │   └── operator_loc: (108,4)-(108,6) = "in"
        ├── @ MatchPredicateNode (location: (109,0)-(109,12))
        │   ├── value:
        │   │   @ CallNode (location: (109,0)-(109,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (109,0)-(109,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ XStringNode (location: (109,7)-(109,12))
        │   │   ├── opening_loc: (109,7)-(109,8) = "`"
        │   │   ├── content_loc: (109,8)-(109,11) = "foo"
        │   │   ├── closing_loc: (109,11)-(109,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (109,4)-(109,6) = "in"
        ├── @ MatchPredicateNode (location: (110,0)-(110,14))
        │   ├── value:
        │   │   @ CallNode (location: (110,0)-(110,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (110,0)-(110,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ XStringNode (location: (110,7)-(110,14))
        │   │   ├── opening_loc: (110,7)-(110,10) = "%x["
        │   │   ├── content_loc: (110,10)-(110,13) = "foo"
        │   │   ├── closing_loc: (110,13)-(110,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (110,4)-(110,6) = "in"
        ├── @ MatchPredicateNode (location: (111,0)-(111,14))
        │   ├── value:
        │   │   @ CallNode (location: (111,0)-(111,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (111,0)-(111,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (111,7)-(111,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (111,10)-(111,13))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (111,10)-(111,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (111,7)-(111,10) = "%i["
        │   │   ├── closing_loc: (111,13)-(111,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (111,4)-(111,6) = "in"
        ├── @ MatchPredicateNode (location: (112,0)-(112,14))
        │   ├── value:
        │   │   @ CallNode (location: (112,0)-(112,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (112,0)-(112,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (112,7)-(112,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (112,10)-(112,13))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (112,10)-(112,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (112,7)-(112,10) = "%I["
        │   │   ├── closing_loc: (112,13)-(112,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (112,4)-(112,6) = "in"
        ├── @ MatchPredicateNode (location: (113,0)-(113,14))
        │   ├── value:
        │   │   @ CallNode (location: (113,0)-(113,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (113,0)-(113,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (113,7)-(113,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (113,10)-(113,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (113,10)-(113,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (113,7)-(113,10) = "%w["
        │   │   ├── closing_loc: (113,13)-(113,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (113,4)-(113,6) = "in"
        ├── @ MatchPredicateNode (location: (114,0)-(114,14))
        │   ├── value:
        │   │   @ CallNode (location: (114,0)-(114,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (114,0)-(114,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayNode (location: (114,7)-(114,14))
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (114,10)-(114,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (114,10)-(114,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (114,7)-(114,10) = "%W["
        │   │   ├── closing_loc: (114,13)-(114,14) = "]"
        │   │   └── flags: ∅
        │   └── operator_loc: (114,4)-(114,6) = "in"
        ├── @ MatchPredicateNode (location: (115,0)-(115,14))
        │   ├── value:
        │   │   @ CallNode (location: (115,0)-(115,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (115,0)-(115,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (115,7)-(115,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (115,7)-(115,10) = "%q["
        │   │   ├── content_loc: (115,10)-(115,13) = "foo"
        │   │   ├── closing_loc: (115,13)-(115,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (115,4)-(115,6) = "in"
        ├── @ MatchPredicateNode (location: (116,0)-(116,14))
        │   ├── value:
        │   │   @ CallNode (location: (116,0)-(116,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (116,0)-(116,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (116,7)-(116,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (116,7)-(116,10) = "%Q["
        │   │   ├── content_loc: (116,10)-(116,13) = "foo"
        │   │   ├── closing_loc: (116,13)-(116,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (116,4)-(116,6) = "in"
        ├── @ MatchPredicateNode (location: (117,0)-(117,12))
        │   ├── value:
        │   │   @ CallNode (location: (117,0)-(117,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (117,0)-(117,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ StringNode (location: (117,7)-(117,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (117,7)-(117,8) = "\""
        │   │   ├── content_loc: (117,8)-(117,11) = "foo"
        │   │   ├── closing_loc: (117,11)-(117,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (117,4)-(117,6) = "in"
        ├── @ MatchPredicateNode (location: (118,0)-(118,10))
        │   ├── value:
        │   │   @ CallNode (location: (118,0)-(118,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (118,0)-(118,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ NilNode (location: (118,7)-(118,10))
        │   └── operator_loc: (118,4)-(118,6) = "in"
        ├── @ MatchPredicateNode (location: (119,0)-(119,11))
        │   ├── value:
        │   │   @ CallNode (location: (119,0)-(119,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (119,0)-(119,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SelfNode (location: (119,7)-(119,11))
        │   └── operator_loc: (119,4)-(119,6) = "in"
        ├── @ MatchPredicateNode (location: (120,0)-(120,11))
        │   ├── value:
        │   │   @ CallNode (location: (120,0)-(120,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (120,0)-(120,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ TrueNode (location: (120,7)-(120,11))
        │   └── operator_loc: (120,4)-(120,6) = "in"
        ├── @ MatchPredicateNode (location: (121,0)-(121,12))
        │   ├── value:
        │   │   @ CallNode (location: (121,0)-(121,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (121,0)-(121,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ FalseNode (location: (121,7)-(121,12))
        │   └── operator_loc: (121,4)-(121,6) = "in"
        ├── @ MatchPredicateNode (location: (122,0)-(122,15))
        │   ├── value:
        │   │   @ CallNode (location: (122,0)-(122,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (122,0)-(122,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (122,7)-(122,15))
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (122,4)-(122,6) = "in"
        ├── @ MatchPredicateNode (location: (123,0)-(123,15))
        │   ├── value:
        │   │   @ CallNode (location: (123,0)-(123,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (123,0)-(123,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (123,7)-(123,15))
        │   └── operator_loc: (123,4)-(123,6) = "in"
        ├── @ MatchPredicateNode (location: (124,0)-(124,19))
        │   ├── value:
        │   │   @ CallNode (location: (124,0)-(124,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (124,0)-(124,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (124,7)-(124,19))
        │   └── operator_loc: (124,4)-(124,6) = "in"
        ├── @ MatchPredicateNode (location: (125,0)-(125,17))
        │   ├── value:
        │   │   @ CallNode (location: (125,0)-(125,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (125,0)-(125,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ LambdaNode (location: (125,7)-(125,17))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (125,7)-(125,9) = "->"
        │   │   ├── opening_loc: (125,10)-(125,11) = "{"
        │   │   ├── closing_loc: (125,16)-(125,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (125,12)-(125,15))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (125,12)-(125,15))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (125,4)-(125,6) = "in"
        ├── @ CaseMatchNode (location: (127,0)-(127,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (127,5)-(127,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (127,5)-(127,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (127,10)-(127,21))
        │   │       ├── pattern:
        │   │       │   @ LocalVariableTargetNode (location: (127,13)-(127,16))
        │   │       │   ├── name: :bar
        │   │       │   └── depth: 0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (127,10)-(127,12) = "in"
        │   │       └── then_loc: (127,17)-(127,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (127,0)-(127,4) = "case"
        │   └── end_keyword_loc: (127,22)-(127,25) = "end"
        ├── @ CaseMatchNode (location: (128,0)-(128,23))
        │   ├── predicate:
        │   │   @ CallNode (location: (128,5)-(128,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (128,5)-(128,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (128,10)-(128,19))
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (128,13)-(128,14))
        │   │       │   └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (128,10)-(128,12) = "in"
        │   │       └── then_loc: (128,15)-(128,19) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (128,0)-(128,4) = "case"
        │   └── end_keyword_loc: (128,20)-(128,23) = "end"
        ├── @ CaseMatchNode (location: (129,0)-(129,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (129,5)-(129,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (129,5)-(129,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (129,10)-(129,21))
        │   │       ├── pattern:
        │   │       │   @ FloatNode (location: (129,13)-(129,16))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (129,10)-(129,12) = "in"
        │   │       └── then_loc: (129,17)-(129,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (129,0)-(129,4) = "case"
        │   └── end_keyword_loc: (129,22)-(129,25) = "end"
        ├── @ CaseMatchNode (location: (130,0)-(130,24))
        │   ├── predicate:
        │   │   @ CallNode (location: (130,5)-(130,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (130,5)-(130,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (130,10)-(130,20))
        │   │       ├── pattern:
        │   │       │   @ ImaginaryNode (location: (130,13)-(130,15))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (130,13)-(130,14))
        │   │       │       └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (130,10)-(130,12) = "in"
        │   │       └── then_loc: (130,16)-(130,20) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (130,0)-(130,4) = "case"
        │   └── end_keyword_loc: (130,21)-(130,24) = "end"
        ├── @ CaseMatchNode (location: (131,0)-(131,24))
        │   ├── predicate:
        │   │   @ CallNode (location: (131,5)-(131,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (131,5)-(131,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (131,10)-(131,20))
        │   │       ├── pattern:
        │   │       │   @ RationalNode (location: (131,13)-(131,15))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (131,13)-(131,14))
        │   │       │       └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (131,10)-(131,12) = "in"
        │   │       └── then_loc: (131,16)-(131,20) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (131,0)-(131,4) = "case"
        │   └── end_keyword_loc: (131,21)-(131,24) = "end"
        ├── @ CaseMatchNode (location: (132,0)-(132,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (132,5)-(132,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (132,5)-(132,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (132,10)-(132,22))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (132,13)-(132,17))
        │   │       │   ├── opening_loc: (132,13)-(132,14) = ":"
        │   │       │   ├── value_loc: (132,14)-(132,17) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (132,10)-(132,12) = "in"
        │   │       └── then_loc: (132,18)-(132,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (132,0)-(132,4) = "case"
        │   └── end_keyword_loc: (132,23)-(132,26) = "end"
        ├── @ CaseMatchNode (location: (133,0)-(133,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (133,5)-(133,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (133,5)-(133,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (133,10)-(133,25))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (133,13)-(133,20))
        │   │       │   ├── opening_loc: (133,13)-(133,16) = "%s["
        │   │       │   ├── value_loc: (133,16)-(133,19) = "foo"
        │   │       │   ├── closing_loc: (133,19)-(133,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (133,10)-(133,12) = "in"
        │   │       └── then_loc: (133,21)-(133,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (133,0)-(133,4) = "case"
        │   └── end_keyword_loc: (133,26)-(133,29) = "end"
        ├── @ CaseMatchNode (location: (134,0)-(134,28))
        │   ├── predicate:
        │   │   @ CallNode (location: (134,5)-(134,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (134,5)-(134,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (134,10)-(134,24))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (134,13)-(134,19))
        │   │       │   ├── opening_loc: (134,13)-(134,15) = ":\""
        │   │       │   ├── value_loc: (134,15)-(134,18) = "foo"
        │   │       │   ├── closing_loc: (134,18)-(134,19) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (134,10)-(134,12) = "in"
        │   │       └── then_loc: (134,20)-(134,24) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (134,0)-(134,4) = "case"
        │   └── end_keyword_loc: (134,25)-(134,28) = "end"
        ├── @ CaseMatchNode (location: (135,0)-(135,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (135,5)-(135,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (135,5)-(135,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (135,10)-(135,23))
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (135,13)-(135,18))
        │   │       │   ├── opening_loc: (135,13)-(135,14) = "/"
        │   │       │   ├── content_loc: (135,14)-(135,17) = "foo"
        │   │       │   ├── closing_loc: (135,17)-(135,18) = "/"
        │   │       │   ├── unescaped: "foo"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (135,10)-(135,12) = "in"
        │   │       └── then_loc: (135,19)-(135,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (135,0)-(135,4) = "case"
        │   └── end_keyword_loc: (135,24)-(135,27) = "end"
        ├── @ CaseMatchNode (location: (136,0)-(136,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (136,5)-(136,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (136,5)-(136,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (136,10)-(136,23))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (136,13)-(136,18))
        │   │       │   ├── opening_loc: (136,13)-(136,14) = "`"
        │   │       │   ├── content_loc: (136,14)-(136,17) = "foo"
        │   │       │   ├── closing_loc: (136,17)-(136,18) = "`"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (136,10)-(136,12) = "in"
        │   │       └── then_loc: (136,19)-(136,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (136,0)-(136,4) = "case"
        │   └── end_keyword_loc: (136,24)-(136,27) = "end"
        ├── @ CaseMatchNode (location: (137,0)-(137,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (137,5)-(137,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (137,5)-(137,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (137,10)-(137,25))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (137,13)-(137,20))
        │   │       │   ├── opening_loc: (137,13)-(137,16) = "%x["
        │   │       │   ├── content_loc: (137,16)-(137,19) = "foo"
        │   │       │   ├── closing_loc: (137,19)-(137,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (137,10)-(137,12) = "in"
        │   │       └── then_loc: (137,21)-(137,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (137,0)-(137,4) = "case"
        │   └── end_keyword_loc: (137,26)-(137,29) = "end"
        ├── @ CaseMatchNode (location: (138,0)-(138,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (138,5)-(138,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (138,5)-(138,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (138,10)-(138,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (138,13)-(138,20))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (138,16)-(138,19))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (138,16)-(138,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (138,13)-(138,16) = "%i["
        │   │       │   ├── closing_loc: (138,19)-(138,20) = "]"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (138,10)-(138,12) = "in"
        │   │       └── then_loc: (138,21)-(138,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (138,0)-(138,4) = "case"
        │   └── end_keyword_loc: (138,26)-(138,29) = "end"
        ├── @ CaseMatchNode (location: (139,0)-(139,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (139,5)-(139,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (139,5)-(139,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (139,10)-(139,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (139,13)-(139,20))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (139,16)-(139,19))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (139,16)-(139,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (139,13)-(139,16) = "%I["
        │   │       │   ├── closing_loc: (139,19)-(139,20) = "]"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (139,10)-(139,12) = "in"
        │   │       └── then_loc: (139,21)-(139,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (139,0)-(139,4) = "case"
        │   └── end_keyword_loc: (139,26)-(139,29) = "end"
        ├── @ CaseMatchNode (location: (140,0)-(140,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (140,5)-(140,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (140,5)-(140,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (140,10)-(140,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (140,13)-(140,20))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (140,16)-(140,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (140,16)-(140,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (140,13)-(140,16) = "%w["
        │   │       │   ├── closing_loc: (140,19)-(140,20) = "]"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (140,10)-(140,12) = "in"
        │   │       └── then_loc: (140,21)-(140,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (140,0)-(140,4) = "case"
        │   └── end_keyword_loc: (140,26)-(140,29) = "end"
        ├── @ CaseMatchNode (location: (141,0)-(141,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (141,5)-(141,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (141,5)-(141,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (141,10)-(141,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (141,13)-(141,20))
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (141,16)-(141,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (141,16)-(141,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (141,13)-(141,16) = "%W["
        │   │       │   ├── closing_loc: (141,19)-(141,20) = "]"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (141,10)-(141,12) = "in"
        │   │       └── then_loc: (141,21)-(141,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (141,0)-(141,4) = "case"
        │   └── end_keyword_loc: (141,26)-(141,29) = "end"
        ├── @ CaseMatchNode (location: (142,0)-(142,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (142,5)-(142,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (142,5)-(142,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (142,10)-(142,25))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (142,13)-(142,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (142,13)-(142,16) = "%q["
        │   │       │   ├── content_loc: (142,16)-(142,19) = "foo"
        │   │       │   ├── closing_loc: (142,19)-(142,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (142,10)-(142,12) = "in"
        │   │       └── then_loc: (142,21)-(142,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (142,0)-(142,4) = "case"
        │   └── end_keyword_loc: (142,26)-(142,29) = "end"
        ├── @ CaseMatchNode (location: (143,0)-(143,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (143,5)-(143,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (143,5)-(143,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (143,10)-(143,25))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (143,13)-(143,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (143,13)-(143,16) = "%Q["
        │   │       │   ├── content_loc: (143,16)-(143,19) = "foo"
        │   │       │   ├── closing_loc: (143,19)-(143,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (143,10)-(143,12) = "in"
        │   │       └── then_loc: (143,21)-(143,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (143,0)-(143,4) = "case"
        │   └── end_keyword_loc: (143,26)-(143,29) = "end"
        ├── @ CaseMatchNode (location: (144,0)-(144,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (144,5)-(144,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (144,5)-(144,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (144,10)-(144,23))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (144,13)-(144,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (144,13)-(144,14) = "\""
        │   │       │   ├── content_loc: (144,14)-(144,17) = "foo"
        │   │       │   ├── closing_loc: (144,17)-(144,18) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (144,10)-(144,12) = "in"
        │   │       └── then_loc: (144,19)-(144,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (144,0)-(144,4) = "case"
        │   └── end_keyword_loc: (144,24)-(144,27) = "end"
        ├── @ CaseMatchNode (location: (145,0)-(145,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (145,5)-(145,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (145,5)-(145,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (145,10)-(145,21))
        │   │       ├── pattern:
        │   │       │   @ NilNode (location: (145,13)-(145,16))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (145,10)-(145,12) = "in"
        │   │       └── then_loc: (145,17)-(145,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (145,0)-(145,4) = "case"
        │   └── end_keyword_loc: (145,22)-(145,25) = "end"
        ├── @ CaseMatchNode (location: (146,0)-(146,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (146,5)-(146,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (146,5)-(146,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (146,10)-(146,22))
        │   │       ├── pattern:
        │   │       │   @ SelfNode (location: (146,13)-(146,17))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (146,10)-(146,12) = "in"
        │   │       └── then_loc: (146,18)-(146,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (146,0)-(146,4) = "case"
        │   └── end_keyword_loc: (146,23)-(146,26) = "end"
        ├── @ CaseMatchNode (location: (147,0)-(147,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (147,5)-(147,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (147,5)-(147,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (147,10)-(147,22))
        │   │       ├── pattern:
        │   │       │   @ TrueNode (location: (147,13)-(147,17))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (147,10)-(147,12) = "in"
        │   │       └── then_loc: (147,18)-(147,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (147,0)-(147,4) = "case"
        │   └── end_keyword_loc: (147,23)-(147,26) = "end"
        ├── @ CaseMatchNode (location: (148,0)-(148,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (148,5)-(148,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (148,5)-(148,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (148,10)-(148,23))
        │   │       ├── pattern:
        │   │       │   @ FalseNode (location: (148,13)-(148,18))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (148,10)-(148,12) = "in"
        │   │       └── then_loc: (148,19)-(148,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (148,0)-(148,4) = "case"
        │   └── end_keyword_loc: (148,24)-(148,27) = "end"
        ├── @ CaseMatchNode (location: (149,0)-(149,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (149,5)-(149,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (149,5)-(149,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (149,10)-(149,26))
        │   │       ├── pattern:
        │   │       │   @ SourceFileNode (location: (149,13)-(149,21))
        │   │       │   └── filepath: "patterns.txt"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (149,10)-(149,12) = "in"
        │   │       └── then_loc: (149,22)-(149,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (149,0)-(149,4) = "case"
        │   └── end_keyword_loc: (149,27)-(149,30) = "end"
        ├── @ CaseMatchNode (location: (150,0)-(150,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (150,5)-(150,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (150,5)-(150,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (150,10)-(150,26))
        │   │       ├── pattern:
        │   │       │   @ SourceLineNode (location: (150,13)-(150,21))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (150,10)-(150,12) = "in"
        │   │       └── then_loc: (150,22)-(150,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (150,0)-(150,4) = "case"
        │   └── end_keyword_loc: (150,27)-(150,30) = "end"
        ├── @ CaseMatchNode (location: (151,0)-(151,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (151,5)-(151,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (151,5)-(151,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (151,10)-(151,30))
        │   │       ├── pattern:
        │   │       │   @ SourceEncodingNode (location: (151,13)-(151,25))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (151,10)-(151,12) = "in"
        │   │       └── then_loc: (151,26)-(151,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (151,0)-(151,4) = "case"
        │   └── end_keyword_loc: (151,31)-(151,34) = "end"
        ├── @ CaseMatchNode (location: (152,0)-(152,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (152,5)-(152,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (152,5)-(152,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (152,10)-(152,28))
        │   │       ├── pattern:
        │   │       │   @ LambdaNode (location: (152,13)-(152,23))
        │   │       │   ├── locals: []
        │   │       │   ├── operator_loc: (152,13)-(152,15) = "->"
        │   │       │   ├── opening_loc: (152,16)-(152,17) = "{"
        │   │       │   ├── closing_loc: (152,22)-(152,23) = "}"
        │   │       │   ├── parameters: ∅
        │   │       │   └── body:
        │   │       │       @ StatementsNode (location: (152,18)-(152,21))
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ LocalVariableReadNode (location: (152,18)-(152,21))
        │   │       │               ├── name: :bar
        │   │       │               └── depth: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (152,10)-(152,12) = "in"
        │   │       └── then_loc: (152,24)-(152,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (152,0)-(152,4) = "case"
        │   └── end_keyword_loc: (152,29)-(152,32) = "end"
        ├── @ CaseMatchNode (location: (154,0)-(154,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (154,5)-(154,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (154,5)-(154,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (154,10)-(154,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (154,13)-(154,23))
        │   │       │   ├── if_keyword_loc: (154,17)-(154,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (154,20)-(154,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (154,13)-(154,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (154,13)-(154,16))
        │   │       │   │           ├── name: :bar
        │   │       │   │           └── depth: 0
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (154,10)-(154,12) = "in"
        │   │       └── then_loc: (154,24)-(154,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (154,0)-(154,4) = "case"
        │   └── end_keyword_loc: (154,29)-(154,32) = "end"
        ├── @ CaseMatchNode (location: (155,0)-(155,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (155,5)-(155,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (155,5)-(155,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (155,10)-(155,26))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (155,13)-(155,21))
        │   │       │   ├── if_keyword_loc: (155,15)-(155,17) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (155,18)-(155,21))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (155,13)-(155,14))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (155,13)-(155,14))
        │   │       │   │           └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (155,10)-(155,12) = "in"
        │   │       └── then_loc: (155,22)-(155,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (155,0)-(155,4) = "case"
        │   └── end_keyword_loc: (155,27)-(155,30) = "end"
        ├── @ CaseMatchNode (location: (156,0)-(156,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (156,5)-(156,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (156,5)-(156,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (156,10)-(156,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (156,13)-(156,23))
        │   │       │   ├── if_keyword_loc: (156,17)-(156,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (156,20)-(156,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (156,13)-(156,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FloatNode (location: (156,13)-(156,16))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (156,10)-(156,12) = "in"
        │   │       └── then_loc: (156,24)-(156,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (156,0)-(156,4) = "case"
        │   └── end_keyword_loc: (156,29)-(156,32) = "end"
        ├── @ CaseMatchNode (location: (157,0)-(157,31))
        │   ├── predicate:
        │   │   @ CallNode (location: (157,5)-(157,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (157,5)-(157,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (157,10)-(157,27))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (157,13)-(157,22))
        │   │       │   ├── if_keyword_loc: (157,16)-(157,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (157,19)-(157,22))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (157,13)-(157,15))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ImaginaryNode (location: (157,13)-(157,15))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (157,13)-(157,14))
        │   │       │   │               └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (157,10)-(157,12) = "in"
        │   │       └── then_loc: (157,23)-(157,27) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (157,0)-(157,4) = "case"
        │   └── end_keyword_loc: (157,28)-(157,31) = "end"
        ├── @ CaseMatchNode (location: (158,0)-(158,31))
        │   ├── predicate:
        │   │   @ CallNode (location: (158,5)-(158,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (158,5)-(158,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (158,10)-(158,27))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (158,13)-(158,22))
        │   │       │   ├── if_keyword_loc: (158,16)-(158,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (158,19)-(158,22))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (158,13)-(158,15))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RationalNode (location: (158,13)-(158,15))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (158,13)-(158,14))
        │   │       │   │               └── flags: decimal
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (158,10)-(158,12) = "in"
        │   │       └── then_loc: (158,23)-(158,27) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (158,0)-(158,4) = "case"
        │   └── end_keyword_loc: (158,28)-(158,31) = "end"
        ├── @ CaseMatchNode (location: (159,0)-(159,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (159,5)-(159,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (159,5)-(159,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (159,10)-(159,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (159,13)-(159,24))
        │   │       │   ├── if_keyword_loc: (159,18)-(159,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (159,21)-(159,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (159,13)-(159,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (159,13)-(159,17))
        │   │       │   │           ├── opening_loc: (159,13)-(159,14) = ":"
        │   │       │   │           ├── value_loc: (159,14)-(159,17) = "foo"
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (159,10)-(159,12) = "in"
        │   │       └── then_loc: (159,25)-(159,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (159,0)-(159,4) = "case"
        │   └── end_keyword_loc: (159,30)-(159,33) = "end"
        ├── @ CaseMatchNode (location: (160,0)-(160,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (160,5)-(160,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (160,5)-(160,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (160,10)-(160,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (160,13)-(160,27))
        │   │       │   ├── if_keyword_loc: (160,21)-(160,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (160,24)-(160,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (160,13)-(160,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (160,13)-(160,20))
        │   │       │   │           ├── opening_loc: (160,13)-(160,16) = "%s["
        │   │       │   │           ├── value_loc: (160,16)-(160,19) = "foo"
        │   │       │   │           ├── closing_loc: (160,19)-(160,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (160,10)-(160,12) = "in"
        │   │       └── then_loc: (160,28)-(160,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (160,0)-(160,4) = "case"
        │   └── end_keyword_loc: (160,33)-(160,36) = "end"
        ├── @ CaseMatchNode (location: (161,0)-(161,35))
        │   ├── predicate:
        │   │   @ CallNode (location: (161,5)-(161,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (161,5)-(161,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (161,10)-(161,31))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (161,13)-(161,26))
        │   │       │   ├── if_keyword_loc: (161,20)-(161,22) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (161,23)-(161,26))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (161,13)-(161,19))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (161,13)-(161,19))
        │   │       │   │           ├── opening_loc: (161,13)-(161,15) = ":\""
        │   │       │   │           ├── value_loc: (161,15)-(161,18) = "foo"
        │   │       │   │           ├── closing_loc: (161,18)-(161,19) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (161,10)-(161,12) = "in"
        │   │       └── then_loc: (161,27)-(161,31) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (161,0)-(161,4) = "case"
        │   └── end_keyword_loc: (161,32)-(161,35) = "end"
        ├── @ CaseMatchNode (location: (162,0)-(162,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (162,5)-(162,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (162,5)-(162,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (162,10)-(162,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (162,13)-(162,25))
        │   │       │   ├── if_keyword_loc: (162,19)-(162,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (162,22)-(162,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (162,13)-(162,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RegularExpressionNode (location: (162,13)-(162,18))
        │   │       │   │           ├── opening_loc: (162,13)-(162,14) = "/"
        │   │       │   │           ├── content_loc: (162,14)-(162,17) = "foo"
        │   │       │   │           ├── closing_loc: (162,17)-(162,18) = "/"
        │   │       │   │           ├── unescaped: "foo"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (162,10)-(162,12) = "in"
        │   │       └── then_loc: (162,26)-(162,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (162,0)-(162,4) = "case"
        │   └── end_keyword_loc: (162,31)-(162,34) = "end"
        ├── @ CaseMatchNode (location: (163,0)-(163,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (163,5)-(163,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (163,5)-(163,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (163,10)-(163,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (163,13)-(163,25))
        │   │       │   ├── if_keyword_loc: (163,19)-(163,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (163,22)-(163,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (163,13)-(163,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (163,13)-(163,18))
        │   │       │   │           ├── opening_loc: (163,13)-(163,14) = "`"
        │   │       │   │           ├── content_loc: (163,14)-(163,17) = "foo"
        │   │       │   │           ├── closing_loc: (163,17)-(163,18) = "`"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (163,10)-(163,12) = "in"
        │   │       └── then_loc: (163,26)-(163,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (163,0)-(163,4) = "case"
        │   └── end_keyword_loc: (163,31)-(163,34) = "end"
        ├── @ CaseMatchNode (location: (164,0)-(164,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (164,5)-(164,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (164,5)-(164,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (164,10)-(164,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (164,13)-(164,27))
        │   │       │   ├── if_keyword_loc: (164,21)-(164,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (164,24)-(164,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (164,13)-(164,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (164,13)-(164,20))
        │   │       │   │           ├── opening_loc: (164,13)-(164,16) = "%x["
        │   │       │   │           ├── content_loc: (164,16)-(164,19) = "foo"
        │   │       │   │           ├── closing_loc: (164,19)-(164,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (164,10)-(164,12) = "in"
        │   │       └── then_loc: (164,28)-(164,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (164,0)-(164,4) = "case"
        │   └── end_keyword_loc: (164,33)-(164,36) = "end"
        ├── @ CaseMatchNode (location: (165,0)-(165,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (165,5)-(165,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (165,5)-(165,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (165,10)-(165,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (165,13)-(165,27))
        │   │       │   ├── if_keyword_loc: (165,21)-(165,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (165,24)-(165,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (165,13)-(165,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (165,13)-(165,20))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (165,16)-(165,19))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (165,16)-(165,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (165,13)-(165,16) = "%i["
        │   │       │   │           ├── closing_loc: (165,19)-(165,20) = "]"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (165,10)-(165,12) = "in"
        │   │       └── then_loc: (165,28)-(165,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (165,0)-(165,4) = "case"
        │   └── end_keyword_loc: (165,33)-(165,36) = "end"
        ├── @ CaseMatchNode (location: (166,0)-(166,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (166,5)-(166,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (166,5)-(166,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (166,10)-(166,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (166,13)-(166,27))
        │   │       │   ├── if_keyword_loc: (166,21)-(166,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (166,24)-(166,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (166,13)-(166,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (166,13)-(166,20))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (166,16)-(166,19))
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (166,16)-(166,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (166,13)-(166,16) = "%I["
        │   │       │   │           ├── closing_loc: (166,19)-(166,20) = "]"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (166,10)-(166,12) = "in"
        │   │       └── then_loc: (166,28)-(166,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (166,0)-(166,4) = "case"
        │   └── end_keyword_loc: (166,33)-(166,36) = "end"
        ├── @ CaseMatchNode (location: (167,0)-(167,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (167,5)-(167,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (167,5)-(167,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (167,10)-(167,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (167,13)-(167,27))
        │   │       │   ├── if_keyword_loc: (167,21)-(167,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (167,24)-(167,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (167,13)-(167,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (167,13)-(167,20))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (167,16)-(167,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (167,16)-(167,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (167,13)-(167,16) = "%w["
        │   │       │   │           ├── closing_loc: (167,19)-(167,20) = "]"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (167,10)-(167,12) = "in"
        │   │       └── then_loc: (167,28)-(167,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (167,0)-(167,4) = "case"
        │   └── end_keyword_loc: (167,33)-(167,36) = "end"
        ├── @ CaseMatchNode (location: (168,0)-(168,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (168,5)-(168,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (168,5)-(168,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (168,10)-(168,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (168,13)-(168,27))
        │   │       │   ├── if_keyword_loc: (168,21)-(168,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (168,24)-(168,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (168,13)-(168,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (168,13)-(168,20))
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (168,16)-(168,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (168,16)-(168,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (168,13)-(168,16) = "%W["
        │   │       │   │           ├── closing_loc: (168,19)-(168,20) = "]"
        │   │       │   │           └── flags: ∅
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (168,10)-(168,12) = "in"
        │   │       └── then_loc: (168,28)-(168,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (168,0)-(168,4) = "case"
        │   └── end_keyword_loc: (168,33)-(168,36) = "end"
        ├── @ CaseMatchNode (location: (169,0)-(169,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (169,5)-(169,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (169,5)-(169,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (169,10)-(169,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (169,13)-(169,27))
        │   │       │   ├── if_keyword_loc: (169,21)-(169,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (169,24)-(169,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (169,13)-(169,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (169,13)-(169,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (169,13)-(169,16) = "%q["
        │   │       │   │           ├── content_loc: (169,16)-(169,19) = "foo"
        │   │       │   │           ├── closing_loc: (169,19)-(169,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (169,10)-(169,12) = "in"
        │   │       └── then_loc: (169,28)-(169,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (169,0)-(169,4) = "case"
        │   └── end_keyword_loc: (169,33)-(169,36) = "end"
        ├── @ CaseMatchNode (location: (170,0)-(170,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (170,5)-(170,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (170,5)-(170,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (170,10)-(170,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (170,13)-(170,27))
        │   │       │   ├── if_keyword_loc: (170,21)-(170,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (170,24)-(170,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (170,13)-(170,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (170,13)-(170,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (170,13)-(170,16) = "%Q["
        │   │       │   │           ├── content_loc: (170,16)-(170,19) = "foo"
        │   │       │   │           ├── closing_loc: (170,19)-(170,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (170,10)-(170,12) = "in"
        │   │       └── then_loc: (170,28)-(170,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (170,0)-(170,4) = "case"
        │   └── end_keyword_loc: (170,33)-(170,36) = "end"
        ├── @ CaseMatchNode (location: (171,0)-(171,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (171,5)-(171,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (171,5)-(171,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (171,10)-(171,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (171,13)-(171,25))
        │   │       │   ├── if_keyword_loc: (171,19)-(171,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (171,22)-(171,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (171,13)-(171,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (171,13)-(171,18))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (171,13)-(171,14) = "\""
        │   │       │   │           ├── content_loc: (171,14)-(171,17) = "foo"
        │   │       │   │           ├── closing_loc: (171,17)-(171,18) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (171,10)-(171,12) = "in"
        │   │       └── then_loc: (171,26)-(171,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (171,0)-(171,4) = "case"
        │   └── end_keyword_loc: (171,31)-(171,34) = "end"
        ├── @ CaseMatchNode (location: (172,0)-(172,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (172,5)-(172,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (172,5)-(172,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (172,10)-(172,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (172,13)-(172,23))
        │   │       │   ├── if_keyword_loc: (172,17)-(172,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (172,20)-(172,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (172,13)-(172,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ NilNode (location: (172,13)-(172,16))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (172,10)-(172,12) = "in"
        │   │       └── then_loc: (172,24)-(172,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (172,0)-(172,4) = "case"
        │   └── end_keyword_loc: (172,29)-(172,32) = "end"
        ├── @ CaseMatchNode (location: (173,0)-(173,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (173,5)-(173,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (173,5)-(173,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (173,10)-(173,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (173,13)-(173,24))
        │   │       │   ├── if_keyword_loc: (173,18)-(173,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (173,21)-(173,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (173,13)-(173,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SelfNode (location: (173,13)-(173,17))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (173,10)-(173,12) = "in"
        │   │       └── then_loc: (173,25)-(173,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (173,0)-(173,4) = "case"
        │   └── end_keyword_loc: (173,30)-(173,33) = "end"
        ├── @ CaseMatchNode (location: (174,0)-(174,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (174,5)-(174,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (174,5)-(174,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (174,10)-(174,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (174,13)-(174,24))
        │   │       │   ├── if_keyword_loc: (174,18)-(174,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (174,21)-(174,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (174,13)-(174,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ TrueNode (location: (174,13)-(174,17))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (174,10)-(174,12) = "in"
        │   │       └── then_loc: (174,25)-(174,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (174,0)-(174,4) = "case"
        │   └── end_keyword_loc: (174,30)-(174,33) = "end"
        ├── @ CaseMatchNode (location: (175,0)-(175,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (175,5)-(175,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (175,5)-(175,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (175,10)-(175,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (175,13)-(175,25))
        │   │       │   ├── if_keyword_loc: (175,19)-(175,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (175,22)-(175,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (175,13)-(175,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FalseNode (location: (175,13)-(175,18))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (175,10)-(175,12) = "in"
        │   │       └── then_loc: (175,26)-(175,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (175,0)-(175,4) = "case"
        │   └── end_keyword_loc: (175,31)-(175,34) = "end"
        ├── @ CaseMatchNode (location: (176,0)-(176,37))
        │   ├── predicate:
        │   │   @ CallNode (location: (176,5)-(176,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (176,5)-(176,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (176,10)-(176,33))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (176,13)-(176,28))
        │   │       │   ├── if_keyword_loc: (176,22)-(176,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (176,25)-(176,28))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (176,13)-(176,21))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceFileNode (location: (176,13)-(176,21))
        │   │       │   │           └── filepath: "patterns.txt"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (176,10)-(176,12) = "in"
        │   │       └── then_loc: (176,29)-(176,33) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (176,0)-(176,4) = "case"
        │   └── end_keyword_loc: (176,34)-(176,37) = "end"
        ├── @ CaseMatchNode (location: (177,0)-(177,37))
        │   ├── predicate:
        │   │   @ CallNode (location: (177,5)-(177,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (177,5)-(177,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (177,10)-(177,33))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (177,13)-(177,28))
        │   │       │   ├── if_keyword_loc: (177,22)-(177,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (177,25)-(177,28))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (177,13)-(177,21))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceLineNode (location: (177,13)-(177,21))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (177,10)-(177,12) = "in"
        │   │       └── then_loc: (177,29)-(177,33) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (177,0)-(177,4) = "case"
        │   └── end_keyword_loc: (177,34)-(177,37) = "end"
        ├── @ CaseMatchNode (location: (178,0)-(178,41))
        │   ├── predicate:
        │   │   @ CallNode (location: (178,5)-(178,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (178,5)-(178,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (178,10)-(178,37))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (178,13)-(178,32))
        │   │       │   ├── if_keyword_loc: (178,26)-(178,28) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (178,29)-(178,32))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (178,13)-(178,25))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceEncodingNode (location: (178,13)-(178,25))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (178,10)-(178,12) = "in"
        │   │       └── then_loc: (178,33)-(178,37) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (178,0)-(178,4) = "case"
        │   └── end_keyword_loc: (178,38)-(178,41) = "end"
        ├── @ CaseMatchNode (location: (179,0)-(179,39))
        │   ├── predicate:
        │   │   @ CallNode (location: (179,5)-(179,8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (179,5)-(179,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (179,10)-(179,35))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (179,13)-(179,30))
        │   │       │   ├── if_keyword_loc: (179,24)-(179,26) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (179,27)-(179,30))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (179,13)-(179,23))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LambdaNode (location: (179,13)-(179,23))
        │   │       │   │           ├── locals: []
        │   │       │   │           ├── operator_loc: (179,13)-(179,15) = "->"
        │   │       │   │           ├── opening_loc: (179,16)-(179,17) = "{"
        │   │       │   │           ├── closing_loc: (179,22)-(179,23) = "}"
        │   │       │   │           ├── parameters: ∅
        │   │       │   │           └── body:
        │   │       │   │               @ StatementsNode (location: (179,18)-(179,21))
        │   │       │   │               └── body: (length: 1)
        │   │       │   │                   └── @ LocalVariableReadNode (location: (179,18)-(179,21))
        │   │       │   │                       ├── name: :bar
        │   │       │   │                       └── depth: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (179,10)-(179,12) = "in"
        │   │       └── then_loc: (179,31)-(179,35) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (179,0)-(179,4) = "case"
        │   └── end_keyword_loc: (179,36)-(179,39) = "end"
        ├── @ IfNode (location: (181,0)-(182,3))
        │   ├── if_keyword_loc: (181,0)-(181,2) = "if"
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (181,3)-(181,10))
        │   │   ├── value:
        │   │   │   @ CallNode (location: (181,3)-(181,4))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (181,3)-(181,4) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   └── flags: variable_call
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (181,8)-(181,10))
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: (181,8)-(181,9) = "["
        │   │   │   └── closing_loc: (181,9)-(181,10) = "]"
        │   │   └── operator_loc: (181,5)-(181,7) = "in"
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (182,0)-(182,3) = "end"
        ├── @ MatchRequiredNode (location: (184,0)-(186,1))
        │   ├── value:
        │   │   @ CallNode (location: (184,0)-(184,1))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (184,0)-(184,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (184,5)-(186,1))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (185,2)-(185,3))
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (184,5)-(184,6) = "["
        │   │   └── closing_loc: (186,0)-(186,1) = "]"
        │   └── operator_loc: (184,2)-(184,4) = "=>"
        ├── @ MatchPredicateNode (location: (188,0)-(192,1))
        │   ├── value:
        │   │   @ CallNode (location: (188,0)-(188,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (188,0)-(188,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (188,7)-(192,1))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (188,7)-(188,8))
        │   │   │   └── name: :A
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (189,2)-(191,3))
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (189,2)-(189,6))
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (189,2)-(189,5) = "bar"
        │   │   │       │   ├── closing_loc: (189,5)-(189,6) = ":"
        │   │   │       │   └── unescaped: "bar"
        │   │   │       ├── value:
        │   │   │       │   @ HashPatternNode (location: (189,7)-(191,3))
        │   │   │       │   ├── constant:
        │   │   │       │   │   @ ConstantReadNode (location: (189,7)-(189,8))
        │   │   │       │   │   └── name: :B
        │   │   │       │   ├── elements: (length: 1)
        │   │   │       │   │   └── @ AssocNode (location: (190,4)-(190,12))
        │   │   │       │   │       ├── key:
        │   │   │       │   │       │   @ SymbolNode (location: (190,4)-(190,10))
        │   │   │       │   │       │   ├── opening_loc: ∅
        │   │   │       │   │       │   ├── value_loc: (190,4)-(190,9) = "value"
        │   │   │       │   │       │   ├── closing_loc: (190,9)-(190,10) = ":"
        │   │   │       │   │       │   └── unescaped: "value"
        │   │   │       │   │       ├── value:
        │   │   │       │   │       │   @ LocalVariableTargetNode (location: (190,11)-(190,12))
        │   │   │       │   │       │   ├── name: :a
        │   │   │       │   │       │   └── depth: 0
        │   │   │       │   │       └── operator_loc: ∅
        │   │   │       │   ├── rest: ∅
        │   │   │       │   ├── opening_loc: (189,8)-(189,9) = "["
        │   │   │       │   └── closing_loc: (191,2)-(191,3) = "]"
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: (188,8)-(188,9) = "["
        │   │   └── closing_loc: (192,0)-(192,1) = "]"
        │   └── operator_loc: (188,4)-(188,6) = "in"
        ├── @ MatchPredicateNode (location: (194,0)-(194,17))
        │   ├── value:
        │   │   @ CallNode (location: (194,0)-(194,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (194,0)-(194,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (194,7)-(194,17))
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (194,7)-(194,10))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (194,14)-(194,17))
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (194,11)-(194,13) = "=>"
        │   └── operator_loc: (194,4)-(194,6) = "in"
        ├── @ MatchRequiredNode (location: (195,0)-(195,17))
        │   ├── value:
        │   │   @ CallNode (location: (195,0)-(195,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (195,0)-(195,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   └── flags: variable_call
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (195,7)-(195,17))
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (195,7)-(195,10))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (195,14)-(195,17))
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (195,11)-(195,13) = "=>"
        │   └── operator_loc: (195,4)-(195,6) = "=>"
        ├── @ MultiWriteNode (location: (197,0)-(197,20))
        │   ├── lefts: (length: 3)
        │   │   ├── @ LocalVariableTargetNode (location: (197,0)-(197,3))
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── @ LocalVariableTargetNode (location: (197,5)-(197,8))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (197,10)-(197,13))
        │   │       ├── name: :baz
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (197,14)-(197,15) = "="
        │   └── value:
        │       @ ArrayNode (location: (197,16)-(197,20))
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (197,16)-(197,17))
        │       │   │   └── flags: decimal
        │       │   └── @ IntegerNode (location: (197,19)-(197,20))
        │       │       └── flags: decimal
        │       ├── opening_loc: ∅
        │       ├── closing_loc: ∅
        │       └── flags: ∅
        └── @ CallNode (location: (198,0)-(200,3))
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (198,0)-(198,3) = "foo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            ├── block:
            │   @ BlockNode (location: (198,4)-(200,3))
            │   ├── locals: []
            │   ├── parameters: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (199,2)-(199,29))
            │   │   └── body: (length: 1)
            │   │       └── @ MatchRequiredNode (location: (199,2)-(199,29))
            │   │           ├── value:
            │   │           │   @ ArrayNode (location: (199,2)-(199,8))
            │   │           │   ├── elements: (length: 2)
            │   │           │   │   ├── @ IntegerNode (location: (199,3)-(199,4))
            │   │           │   │   │   └── flags: decimal
            │   │           │   │   └── @ IntegerNode (location: (199,6)-(199,7))
            │   │           │   │       └── flags: decimal
            │   │           │   ├── opening_loc: (199,2)-(199,3) = "["
            │   │           │   ├── closing_loc: (199,7)-(199,8) = "]"
            │   │           │   └── flags: ∅
            │   │           ├── pattern:
            │   │           │   @ CapturePatternNode (location: (199,12)-(199,29))
            │   │           │   ├── value:
            │   │           │   │   @ ArrayPatternNode (location: (199,12)-(199,22))
            │   │           │   │   ├── constant: ∅
            │   │           │   │   ├── requireds: (length: 2)
            │   │           │   │   │   ├── @ LocalVariableTargetNode (location: (199,13)-(199,16))
            │   │           │   │   │   │   ├── name: :foo
            │   │           │   │   │   │   └── depth: 1
            │   │           │   │   │   └── @ LocalVariableTargetNode (location: (199,18)-(199,21))
            │   │           │   │   │       ├── name: :bar
            │   │           │   │   │       └── depth: 1
            │   │           │   │   ├── rest: ∅
            │   │           │   │   ├── posts: (length: 0)
            │   │           │   │   ├── opening_loc: (199,12)-(199,13) = "["
            │   │           │   │   └── closing_loc: (199,21)-(199,22) = "]"
            │   │           │   ├── target:
            │   │           │   │   @ LocalVariableTargetNode (location: (199,26)-(199,29))
            │   │           │   │   ├── name: :baz
            │   │           │   │   └── depth: 1
            │   │           │   └── operator_loc: (199,23)-(199,25) = "=>"
            │   │           └── operator_loc: (199,9)-(199,11) = "=>"
            │   ├── opening_loc: (198,4)-(198,6) = "do"
            │   └── closing_loc: (200,0)-(200,3) = "end"
            └── flags: ∅