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