@ ProgramNode (location: (0...408))
├── locals: [:a, :x, :y]
└── statements:
    @ StatementsNode (location: (0...408))
    └── body: (length: 4)
        ├── @ CaseNode (location: (0...345))
        │   ├── predicate:
        │   │   @ CallNode (location: (5...8))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (5...8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 15)
        │   │   ├── @ InNode (location: (9...38))
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (12...26))
        │   │   │   │   ├── constant:
        │   │   │   │   │   @ ConstantReadNode (location: (12...13))
        │   │   │   │   │   └── name: :A
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ IntegerNode (location: (14...15))
        │   │   │   │   │   │   └── flags: decimal
        │   │   │   │   │   └── @ IntegerNode (location: (17...18))
        │   │   │   │   │       └── flags: decimal
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (20...22))
        │   │   │   │   │   ├── operator_loc: (20...21) = "*"
        │   │   │   │   │   └── expression:
        │   │   │   │   │       @ LocalVariableTargetNode (location: (21...22))
        │   │   │   │   │       ├── name: :a
        │   │   │   │   │       └── depth: 0
        │   │   │   │   ├── posts: (length: 1)
        │   │   │   │   │   └── @ IntegerNode (location: (24...25))
        │   │   │   │   │       └── flags: decimal
        │   │   │   │   ├── opening_loc: (13...14) = "["
        │   │   │   │   └── closing_loc: (25...26) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (34...38))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (34...38))
        │   │   │   ├── in_loc: (9...11) = "in"
        │   │   │   └── then_loc: (27...31) = "then"
        │   │   ├── @ InNode (location: (39...59))
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (42...50))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ IntegerNode (location: (43...44))
        │   │   │   │   │   │   └── flags: decimal
        │   │   │   │   │   └── @ IntegerNode (location: (46...47))
        │   │   │   │   │       └── flags: decimal
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── opening_loc: (42...43) = "["
        │   │   │   │   └── closing_loc: (49...50) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (58...59))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (58...59))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (58...59) = "y"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "y"
        │   │   │   ├── in_loc: (39...41) = "in"
        │   │   │   └── then_loc: (51...55) = "then"
        │   │   ├── @ InNode (location: (60...80))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (63...68))
        │   │   │   │   ├── constant:
        │   │   │   │   │   @ ConstantReadNode (location: (63...64))
        │   │   │   │   │   └── name: :A
        │   │   │   │   ├── assocs: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (65...67))
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (65...67))
        │   │   │   │   │       │   ├── opening_loc: ∅
        │   │   │   │   │       │   ├── value_loc: (65...66) = "x"
        │   │   │   │   │       │   ├── closing_loc: (66...67) = ":"
        │   │   │   │   │       │   └── unescaped: "x"
        │   │   │   │   │       ├── value: ∅
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (64...65) = "("
        │   │   │   │   └── closing_loc: (67...68) = ")"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (76...80))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (76...80))
        │   │   │   ├── in_loc: (60...62) = "in"
        │   │   │   └── then_loc: (69...73) = "then"
        │   │   ├── @ InNode (location: (81...101))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (84...89))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── assocs: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (85...88))
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ AssocSplatNode (location: (85...88))
        │   │   │   │   │       │   ├── value:
        │   │   │   │   │       │   │   @ LocalVariableTargetNode (location: (87...88))
        │   │   │   │   │       │   │   ├── name: :a
        │   │   │   │   │       │   │   └── depth: 0
        │   │   │   │   │       │   └── operator_loc: (85...87) = "**"
        │   │   │   │   │       ├── value: ∅
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (84...85) = "{"
        │   │   │   │   └── closing_loc: (88...89) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (97...101))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (97...101))
        │   │   │   ├── in_loc: (81...83) = "in"
        │   │   │   └── then_loc: (90...94) = "then"
        │   │   ├── @ InNode (location: (102...127))
        │   │   │   ├── pattern:
        │   │   │   │   @ IfNode (location: (105...115))
        │   │   │   │   ├── if_keyword_loc: (108...110) = "if"
        │   │   │   │   ├── predicate:
        │   │   │   │   │   @ TrueNode (location: (111...115))
        │   │   │   │   ├── statements:
        │   │   │   │   │   @ StatementsNode (location: (105...107))
        │   │   │   │   │   └── body: (length: 1)
        │   │   │   │   │       └── @ HashPatternNode (location: (105...107))
        │   │   │   │   │           ├── constant: ∅
        │   │   │   │   │           ├── assocs: (length: 0)
        │   │   │   │   │           ├── kwrest: ∅
        │   │   │   │   │           ├── opening_loc: (105...106) = "{"
        │   │   │   │   │           └── closing_loc: (106...107) = "}"
        │   │   │   │   ├── consequent: ∅
        │   │   │   │   └── end_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (123...127))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (123...127))
        │   │   │   ├── in_loc: (102...104) = "in"
        │   │   │   └── then_loc: (116...120) = "then"
        │   │   ├── @ InNode (location: (128...152))
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (131...140))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ LocalVariableTargetNode (location: (132...133))
        │   │   │   │   │   │   ├── name: :x
        │   │   │   │   │   │   └── depth: 0
        │   │   │   │   │   └── @ LocalVariableTargetNode (location: (135...136))
        │   │   │   │   │       ├── name: :y
        │   │   │   │   │       └── depth: 0
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (138...139))
        │   │   │   │   │   ├── operator_loc: (138...139) = "*"
        │   │   │   │   │   └── expression: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── opening_loc: (131...132) = "["
        │   │   │   │   └── closing_loc: (139...140) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (148...152))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (148...152))
        │   │   │   ├── in_loc: (128...130) = "in"
        │   │   │   └── then_loc: (141...145) = "then"
        │   │   ├── @ InNode (location: (153...181))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (156...169))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── assocs: (length: 2)
        │   │   │   │   │   ├── @ AssocNode (location: (157...161))
        │   │   │   │   │   │   ├── key:
        │   │   │   │   │   │   │   @ SymbolNode (location: (157...159))
        │   │   │   │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   │   │   │   ├── value_loc: (157...158) = "a"
        │   │   │   │   │   │   │   ├── closing_loc: (158...159) = ":"
        │   │   │   │   │   │   │   └── unescaped: "a"
        │   │   │   │   │   │   ├── value:
        │   │   │   │   │   │   │   @ IntegerNode (location: (160...161))
        │   │   │   │   │   │   │   └── flags: decimal
        │   │   │   │   │   │   └── operator_loc: ∅
        │   │   │   │   │   └── @ AssocNode (location: (163...168))
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (163...166))
        │   │   │   │   │       │   ├── opening_loc: ∅
        │   │   │   │   │       │   ├── value_loc: (163...165) = "aa"
        │   │   │   │   │       │   ├── closing_loc: (165...166) = ":"
        │   │   │   │   │       │   └── unescaped: "aa"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ IntegerNode (location: (167...168))
        │   │   │   │   │       │   └── flags: decimal
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (156...157) = "{"
        │   │   │   │   └── closing_loc: (168...169) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (177...181))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (177...181))
        │   │   │   ├── in_loc: (153...155) = "in"
        │   │   │   └── then_loc: (170...174) = "then"
        │   │   ├── @ InNode (location: (182...199))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (185...187))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── assocs: (length: 0)
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (185...186) = "{"
        │   │   │   │   └── closing_loc: (186...187) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (195...199))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (195...199))
        │   │   │   ├── in_loc: (182...184) = "in"
        │   │   │   └── then_loc: (188...192) = "then"
        │   │   ├── @ InNode (location: (200...222))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (203...210))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── assocs: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (204...209))
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ NoKeywordsParameterNode (location: (204...209))
        │   │   │   │   │       │   ├── operator_loc: (204...206) = "**"
        │   │   │   │   │       │   └── keyword_loc: (206...209) = "nil"
        │   │   │   │   │       ├── value: ∅
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (203...204) = "{"
        │   │   │   │   └── closing_loc: (209...210) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (218...222))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (218...222))
        │   │   │   ├── in_loc: (200...202) = "in"
        │   │   │   └── then_loc: (211...215) = "then"
        │   │   ├── @ InNode (location: (223...246))
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (226...234))
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── assocs: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (227...233))
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (227...231))
        │   │   │   │   │       │   ├── opening_loc: (227...228) = "\""
        │   │   │   │   │       │   ├── value_loc: (228...229) = "a"
        │   │   │   │   │       │   ├── closing_loc: (229...231) = "\":"
        │   │   │   │   │       │   └── unescaped: "a"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ IntegerNode (location: (232...233))
        │   │   │   │   │       │   └── flags: decimal
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── kwrest: ∅
        │   │   │   │   ├── opening_loc: (226...227) = "{"
        │   │   │   │   └── closing_loc: (233...234) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (242...246))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (242...246))
        │   │   │   ├── in_loc: (223...225) = "in"
        │   │   │   └── then_loc: (235...239) = "then"
        │   │   ├── @ InNode (location: (247...267))
        │   │   │   ├── pattern:
        │   │   │   │   @ AlternationPatternNode (location: (250...255))
        │   │   │   │   ├── left:
        │   │   │   │   │   @ IntegerNode (location: (250...251))
        │   │   │   │   │   └── flags: decimal
        │   │   │   │   ├── right:
        │   │   │   │   │   @ IntegerNode (location: (254...255))
        │   │   │   │   │   └── flags: decimal
        │   │   │   │   └── operator_loc: (252...253) = "|"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (263...267))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (263...267))
        │   │   │   ├── in_loc: (247...249) = "in"
        │   │   │   └── then_loc: (256...260) = "then"
        │   │   ├── @ InNode (location: (268...289))
        │   │   │   ├── pattern:
        │   │   │   │   @ CapturePatternNode (location: (271...277))
        │   │   │   │   ├── value:
        │   │   │   │   │   @ IntegerNode (location: (271...272))
        │   │   │   │   │   └── flags: decimal
        │   │   │   │   ├── target:
        │   │   │   │   │   @ LocalVariableTargetNode (location: (276...277))
        │   │   │   │   │   ├── name: :a
        │   │   │   │   │   └── depth: 0
        │   │   │   │   └── operator_loc: (273...275) = "=>"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (285...289))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (285...289))
        │   │   │   ├── in_loc: (268...270) = "in"
        │   │   │   └── then_loc: (278...282) = "then"
        │   │   ├── @ InNode (location: (290...307))
        │   │   │   ├── pattern:
        │   │   │   │   @ PinnedVariableNode (location: (293...295))
        │   │   │   │   ├── variable:
        │   │   │   │   │   @ LocalVariableReadNode (location: (294...295))
        │   │   │   │   │   ├── name: :x
        │   │   │   │   │   └── depth: 0
        │   │   │   │   └── operator_loc: (293...294) = "^"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (303...307))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (303...307))
        │   │   │   ├── in_loc: (290...292) = "in"
        │   │   │   └── then_loc: (296...300) = "then"
        │   │   ├── @ InNode (location: (308...312))
        │   │   │   ├── pattern:
        │   │   │   │   @ IntegerNode (location: (311...312))
        │   │   │   │   └── flags: decimal
        │   │   │   ├── statements: ∅
        │   │   │   ├── in_loc: (308...310) = "in"
        │   │   │   └── then_loc: ∅
        │   │   └── @ InNode (location: (313...329))
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (316...317))
        │   │       │   └── flags: decimal
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (325...329))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (325...329))
        │   │       ├── in_loc: (313...315) = "in"
        │   │       └── then_loc: (318...322) = "then"
        │   ├── consequent:
        │   │   @ ElseNode (location: (330...345))
        │   │   ├── else_keyword_loc: (330...334) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (337...341))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ TrueNode (location: (337...341))
        │   │   └── end_keyword_loc: (342...345) = "end"
        │   ├── case_keyword_loc: (0...4) = "case"
        │   └── end_keyword_loc: (342...345) = "end"
        ├── @ CaseNode (location: (346...376))
        │   ├── predicate:
        │   │   @ CallNode (location: (351...354))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (351...354) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (355...372))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (358...372))
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (358...359))
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ IntegerNode (location: (360...361))
        │   │       │   │   │   └── flags: decimal
        │   │       │   │   └── @ IntegerNode (location: (363...364))
        │   │       │   │       └── flags: decimal
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (366...368))
        │   │       │   │   ├── operator_loc: (366...367) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (367...368))
        │   │       │   │       ├── name: :a
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ IntegerNode (location: (370...371))
        │   │       │   │       └── flags: decimal
        │   │       │   ├── opening_loc: (359...360) = "["
        │   │       │   └── closing_loc: (371...372) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (355...357) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (346...350) = "case"
        │   └── end_keyword_loc: (373...376) = "end"
        ├── @ CaseNode (location: (377...399))
        │   ├── predicate:
        │   │   @ CallNode (location: (382...385))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (382...385) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (386...390))
        │   │       ├── pattern:
        │   │       │   @ ConstantReadNode (location: (389...390))
        │   │       │   └── name: :A
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (386...388) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent:
        │   │   @ ElseNode (location: (391...399))
        │   │   ├── else_keyword_loc: (391...395) = "else"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (396...399) = "end"
        │   ├── case_keyword_loc: (377...381) = "case"
        │   └── end_keyword_loc: (396...399) = "end"
        └── @ MatchPredicateNode (location: (400...408))
            ├── value:
            │   @ IntegerNode (location: (400...401))
            │   └── flags: decimal
            ├── pattern:
            │   @ ArrayPatternNode (location: (405...408))
            │   ├── constant: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ LocalVariableTargetNode (location: (406...407))
            │   │       ├── name: :a
            │   │       └── depth: 0
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── opening_loc: (405...406) = "["
            │   └── closing_loc: (407...408) = "]"
            └── operator_loc: (402...404) = "in"
