@ ProgramNode (location: (1,0)-(48,30))
├── flags: ∅
├── locals: [:b, :c, :a, :_a]
└── statements:
    @ StatementsNode (location: (1,0)-(48,30))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ CaseMatchNode (location: (1,0)-(4,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2,8)-(3,13))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (2,11)-(2,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (2,11)-(2,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (2,11)-(2,13))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (2,11)-(2,12) = "a"
        │   │       │   │   │   │   ├── closing_loc: (2,12)-(2,13) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ HashPatternNode (location: (2,14)-(2,18))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   ├── constant: ∅
        │   │       │   │   │   │   ├── elements: (length: 1)
        │   │       │   │   │   │   │   └── @ AssocNode (location: (2,15)-(2,17))
        │   │       │   │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │   │       ├── key:
        │   │       │   │   │   │   │       │   @ SymbolNode (location: (2,15)-(2,17))
        │   │       │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   │       │   ├── opening_loc: ∅
        │   │       │   │   │   │   │       │   ├── value_loc: (2,15)-(2,16) = "b"
        │   │       │   │   │   │   │       │   ├── closing_loc: (2,16)-(2,17) = ":"
        │   │       │   │   │   │   │       │   └── unescaped: "b"
        │   │       │   │   │   │   │       ├── value:
        │   │       │   │   │   │   │       │   @ ImplicitNode (location: (2,15)-(2,16))
        │   │       │   │   │   │   │       │   ├── flags: ∅
        │   │       │   │   │   │   │       │   └── value:
        │   │       │   │   │   │   │       │       @ LocalVariableTargetNode (location: (2,15)-(2,16))
        │   │       │   │   │   │   │       │       ├── flags: ∅
        │   │       │   │   │   │   │       │       ├── name: :b
        │   │       │   │   │   │   │       │       └── depth: 0
        │   │       │   │   │   │   │       └── operator_loc: ∅
        │   │       │   │   │   │   ├── rest: ∅
        │   │       │   │   │   │   ├── opening_loc: (2,14)-(2,15) = "{"
        │   │       │   │   │   │   └── closing_loc: (2,17)-(2,18) = "}"
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (2,20)-(2,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (2,20)-(2,22))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (2,20)-(2,21) = "c"
        │   │       │   │       │   ├── closing_loc: (2,21)-(2,22) = ":"
        │   │       │   │       │   └── unescaped: "c"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (2,20)-(2,21))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (2,20)-(2,21))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :c
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,10)-(3,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (3,10)-(3,13))
        │   │       │           ├── flags: newline, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :p
        │   │       │           ├── message_loc: (3,10)-(3,11) = "p"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (3,12)-(3,13))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ LocalVariableReadNode (location: (3,12)-(3,13))
        │   │       │           │           ├── flags: ∅
        │   │       │           │           ├── name: :c
        │   │       │           │           └── depth: 0
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── in_loc: (2,8)-(2,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (4,8)-(4,11) = "end"
        ├── @ CaseMatchNode (location: (6,0)-(10,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (6,5)-(6,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (6,5)-(6,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,8)-(9,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (7,11)-(8,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (7,12)-(7,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (7,12)-(7,16))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (7,12)-(7,15) = "Foo"
        │   │       │   │       │   ├── closing_loc: (7,15)-(7,16) = ":"
        │   │       │   │       │   └── unescaped: "Foo"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (7,17)-(7,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 42
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (7,11)-(7,12) = "{"
        │   │       │   └── closing_loc: (8,8)-(8,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,10)-(9,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (9,10)-(9,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,8)-(7,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (6,0)-(6,4) = "case"
        │   └── end_keyword_loc: (10,8)-(10,11) = "end"
        ├── @ CaseMatchNode (location: (12,0)-(16,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (12,5)-(12,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,5)-(12,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (13,8)-(15,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (13,11)-(14,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (13,12)-(14,15))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (13,12)-(13,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (13,12)-(13,13) = "a"
        │   │       │   │       │   ├── closing_loc: (13,13)-(13,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (14,14)-(14,15))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 2
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (13,11)-(13,12) = "{"
        │   │       │   └── closing_loc: (14,15)-(14,16) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (15,10)-(15,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (15,10)-(15,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (13,8)-(13,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (12,0)-(12,4) = "case"
        │   └── end_keyword_loc: (16,8)-(16,11) = "end"
        ├── @ CaseMatchNode (location: (18,0)-(22,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (18,5)-(18,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,5)-(18,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (19,8)-(21,14))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (19,11)-(20,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (19,12)-(19,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (19,12)-(19,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (19,12)-(19,13) = "a"
        │   │       │   │       │   ├── closing_loc: (19,13)-(19,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (19,12)-(19,13))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (19,12)-(19,13))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (19,11)-(19,12) = "{"
        │   │       │   └── closing_loc: (20,8)-(20,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (21,10)-(21,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (21,10)-(21,14))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (19,8)-(19,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (18,0)-(18,4) = "case"
        │   └── end_keyword_loc: (22,8)-(22,11) = "end"
        ├── @ CaseMatchNode (location: (24,0)-(28,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (24,5)-(24,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (24,5)-(24,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (25,8)-(27,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (25,11)-(26,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (25,12)-(25,16))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (25,12)-(25,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (25,12)-(25,13) = "a"
        │   │       │   │       │   ├── closing_loc: (25,13)-(25,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (25,15)-(25,16))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (25,11)-(25,12) = "{"
        │   │       │   └── closing_loc: (26,8)-(26,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (27,10)-(27,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (27,10)-(27,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (25,8)-(25,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (24,0)-(24,4) = "case"
        │   └── end_keyword_loc: (28,8)-(28,11) = "end"
        ├── @ CaseMatchNode (location: (30,0)-(30,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (30,5)-(30,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,5)-(30,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (30,10)-(30,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (30,13)-(30,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (30,13)-(30,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value: ∅
        │   │       │   │   └── operator_loc: (30,13)-(30,15) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (30,21)-(30,25))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (30,21)-(30,25))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (30,10)-(30,12) = "in"
        │   │       └── then_loc: (30,16)-(30,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (30,0)-(30,4) = "case"
        │   └── end_keyword_loc: (30,27)-(30,30) = "end"
        ├── @ CaseMatchNode (location: (32,0)-(32,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (32,5)-(32,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,5)-(32,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (32,10)-(32,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (32,13)-(32,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (32,13)-(32,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value:
        │   │       │   │   │   @ LocalVariableTargetNode (location: (32,15)-(32,16))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :a
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── operator_loc: (32,13)-(32,15) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (32,22)-(32,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (32,22)-(32,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (32,10)-(32,12) = "in"
        │   │       └── then_loc: (32,17)-(32,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (32,0)-(32,4) = "case"
        │   └── end_keyword_loc: (32,28)-(32,31) = "end"
        ├── @ CaseMatchNode (location: (34,0)-(34,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (34,5)-(34,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,5)-(34,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (34,10)-(34,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (34,13)-(34,17))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (34,13)-(34,17))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (34,13)-(34,15))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (34,13)-(34,14) = "a"
        │   │       │   │       │   ├── closing_loc: (34,14)-(34,15) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (34,16)-(34,17))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (34,23)-(34,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (34,23)-(34,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (34,10)-(34,12) = "in"
        │   │       └── then_loc: (34,18)-(34,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (34,0)-(34,4) = "case"
        │   └── end_keyword_loc: (34,29)-(34,32) = "end"
        ├── @ CaseMatchNode (location: (36,0)-(36,41))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (36,5)-(36,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (36,5)-(36,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (36,10)-(36,36))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (36,13)-(36,26))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (36,13)-(36,17))
        │   │       │   │   │   ├── flags: static_literal
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (36,13)-(36,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (36,13)-(36,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (36,14)-(36,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ IntegerNode (location: (36,16)-(36,17))
        │   │       │   │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   │   └── value: 1
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (36,19)-(36,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (36,19)-(36,22))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (36,19)-(36,21) = "_a"
        │   │       │   │       │   ├── closing_loc: (36,21)-(36,22) = ":"
        │   │       │   │       │   └── unescaped: "_a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (36,19)-(36,21))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (36,19)-(36,21))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :_a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (36,24)-(36,26))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value: ∅
        │   │       │   │   └── operator_loc: (36,24)-(36,26) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (36,32)-(36,36))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (36,32)-(36,36))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (36,10)-(36,12) = "in"
        │   │       └── then_loc: (36,27)-(36,31) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (36,0)-(36,4) = "case"
        │   └── end_keyword_loc: (36,38)-(36,41) = "end"
        ├── @ CaseMatchNode (location: (38,0)-(38,38))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (38,5)-(38,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,5)-(38,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (38,10)-(38,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (38,13)-(38,23))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (38,13)-(38,17))
        │   │       │   │   │   ├── flags: static_literal
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (38,13)-(38,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (38,13)-(38,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (38,14)-(38,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ IntegerNode (location: (38,16)-(38,17))
        │   │       │   │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   │   └── value: 1
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (38,19)-(38,23))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (38,19)-(38,21))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (38,19)-(38,20) = "b"
        │   │       │   │       │   ├── closing_loc: (38,20)-(38,21) = ":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (38,22)-(38,23))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 2
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (38,29)-(38,33))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (38,29)-(38,33))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (38,10)-(38,12) = "in"
        │   │       └── then_loc: (38,24)-(38,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (38,0)-(38,4) = "case"
        │   └── end_keyword_loc: (38,35)-(38,38) = "end"
        ├── @ CaseMatchNode (location: (40,0)-(40,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (40,5)-(40,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (40,5)-(40,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (40,10)-(40,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (40,13)-(40,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (40,13)-(40,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (40,13)-(40,15))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (40,13)-(40,14) = "a"
        │   │       │   │       │   ├── closing_loc: (40,14)-(40,15) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (40,13)-(40,14))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (40,13)-(40,14))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (40,21)-(40,25))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (40,21)-(40,25))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (40,10)-(40,12) = "in"
        │   │       └── then_loc: (40,16)-(40,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (40,0)-(40,4) = "case"
        │   └── end_keyword_loc: (40,27)-(40,30) = "end"
        ├── @ CaseMatchNode (location: (42,0)-(42,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (42,5)-(42,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (42,5)-(42,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (42,10)-(42,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (42,13)-(42,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (42,13)-(42,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (42,13)-(42,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (42,13)-(42,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (42,14)-(42,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ ImplicitNode (location: (42,13)-(42,14))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   └── value:
        │   │       │   │   │   │       @ LocalVariableTargetNode (location: (42,13)-(42,14))
        │   │       │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │       ├── name: :a
        │   │       │   │   │   │       └── depth: 0
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (42,17)-(42,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (42,17)-(42,19))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (42,17)-(42,18) = "b"
        │   │       │   │       │   ├── closing_loc: (42,18)-(42,19) = ":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (42,17)-(42,18))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (42,17)-(42,18))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :b
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (42,25)-(42,29))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (42,25)-(42,29))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (42,10)-(42,12) = "in"
        │   │       └── then_loc: (42,20)-(42,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (42,0)-(42,4) = "case"
        │   └── end_keyword_loc: (42,31)-(42,34) = "end"
        ├── @ CaseMatchNode (location: (44,0)-(44,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (44,5)-(44,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,5)-(44,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (44,10)-(44,31))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (44,13)-(44,21))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (44,15)-(44,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (44,15)-(44,17))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (44,15)-(44,16) = "a"
        │   │       │   │       │   ├── closing_loc: (44,16)-(44,17) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (44,18)-(44,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (44,13)-(44,14) = "{"
        │   │       │   └── closing_loc: (44,20)-(44,21) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (44,27)-(44,31))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (44,27)-(44,31))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (44,10)-(44,12) = "in"
        │   │       └── then_loc: (44,22)-(44,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (44,0)-(44,4) = "case"
        │   └── end_keyword_loc: (44,33)-(44,36) = "end"
        ├── @ CaseMatchNode (location: (46,0)-(46,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (46,5)-(46,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (46,5)-(46,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (46,10)-(46,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (46,13)-(46,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (46,15)-(46,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (46,15)-(46,17))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (46,15)-(46,16) = "a"
        │   │       │   │       │   ├── closing_loc: (46,16)-(46,17) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (46,18)-(46,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (46,13)-(46,14) = "{"
        │   │       │   └── closing_loc: (46,21)-(46,22) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (46,28)-(46,32))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (46,28)-(46,32))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (46,10)-(46,12) = "in"
        │   │       └── then_loc: (46,23)-(46,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (46,0)-(46,4) = "case"
        │   └── end_keyword_loc: (46,34)-(46,37) = "end"
        └── @ CaseMatchNode (location: (48,0)-(48,30))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (48,5)-(48,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (48,5)-(48,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (48,10)-(48,25))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (48,13)-(48,15))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 0)
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (48,13)-(48,14) = "{"
            │       │   └── closing_loc: (48,14)-(48,15) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (48,21)-(48,25))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (48,21)-(48,25))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (48,10)-(48,12) = "in"
            │       └── then_loc: (48,16)-(48,20) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (48,0)-(48,4) = "case"
            └── end_keyword_loc: (48,27)-(48,30) = "end"
