@ ProgramNode (location: (0...747))
├── locals: [:b, :_, :lhs, :x, :rhs, :c, :e]
└── statements:
    @ StatementsNode (location: (0...747))
    └── body: (length: 28)
        ├── @ CaseNode (location: (0...21))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (5...7))
        │   │   ├── opening_loc: (5...6) = ":"
        │   │   ├── value_loc: (6...7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (8...16))
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (12...16))
        │   │       │   ├── constant: ∅
        │   │       │   ├── assocs: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (12...16))
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (12...16))
        │   │       │   │       │   ├── opening_loc: (12...13) = "\""
        │   │       │   │       │   ├── value_loc: (13...14) = "b"
        │   │       │   │       │   ├── closing_loc: (14...16) = "\":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value: ∅
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── kwrest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (8...10) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (0...4) = "case"
        │   └── end_keyword_loc: (18...21) = "end"
        ├── @ CaseNode (location: (23...45))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (28...30))
        │   │   ├── opening_loc: (28...29) = ":"
        │   │   ├── value_loc: (29...30) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (31...41))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (34...41))
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (37...38))
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── value_loc: (37...38) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ SymbolNode (location: (39...40))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (39...40) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (34...37) = "%I["
        │   │       │   └── closing_loc: (40...41) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (31...33) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (23...27) = "case"
        │   └── end_keyword_loc: (42...45) = "end"
        ├── @ CaseNode (location: (47...69))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (52...54))
        │   │   ├── opening_loc: (52...53) = ":"
        │   │   ├── value_loc: (53...54) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (55...65))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (58...65))
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ StringNode (location: (61...62))
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (61...62) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ StringNode (location: (63...64))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (63...64) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (58...61) = "%W["
        │   │       │   └── closing_loc: (64...65) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (55...57) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (47...51) = "case"
        │   └── end_keyword_loc: (66...69) = "end"
        ├── @ CaseNode (location: (71...93))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (76...78))
        │   │   ├── opening_loc: (76...77) = ":"
        │   │   ├── value_loc: (77...78) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (79...89))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (82...89))
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (85...86))
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── value_loc: (85...86) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ SymbolNode (location: (87...88))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (87...88) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (82...85) = "%i["
        │   │       │   └── closing_loc: (88...89) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (79...81) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (71...75) = "case"
        │   └── end_keyword_loc: (90...93) = "end"
        ├── @ CaseNode (location: (95...117))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (100...102))
        │   │   ├── opening_loc: (100...101) = ":"
        │   │   ├── value_loc: (101...102) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (103...113))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (106...113))
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ StringNode (location: (109...110))
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (109...110) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ StringNode (location: (111...112))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (111...112) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (106...109) = "%w["
        │   │       │   └── closing_loc: (112...113) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (103...105) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (95...99) = "case"
        │   └── end_keyword_loc: (114...117) = "end"
        ├── @ CaseNode (location: (119...141))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (124...126))
        │   │   ├── opening_loc: (124...125) = ":"
        │   │   ├── value_loc: (125...126) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (127...136))
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (131...136))
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (134...136))
        │   │       │   │   └── flags: decimal
        │   │       │   ├── operator_loc: (131...134) = "..."
        │   │       │   └── flags: exclude_end
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (127...129) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (119...123) = "case"
        │   └── end_keyword_loc: (138...141) = "end"
        ├── @ CaseNode (location: (143...164))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (148...150))
        │   │   ├── opening_loc: (148...149) = ":"
        │   │   ├── value_loc: (149...150) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (151...159))
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (155...159))
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (157...159))
        │   │       │   │   └── flags: decimal
        │   │       │   ├── operator_loc: (155...157) = ".."
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (151...153) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (143...147) = "case"
        │   └── end_keyword_loc: (161...164) = "end"
        ├── @ CaseNode (location: (166...187))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (171...173))
        │   │   ├── opening_loc: (171...172) = ":"
        │   │   ├── value_loc: (172...173) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (174...182))
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (178...182))
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (178...179))
        │   │       │   │   └── flags: decimal
        │   │       │   ├── right: ∅
        │   │       │   ├── operator_loc: (179...182) = "..."
        │   │       │   └── flags: exclude_end
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (174...176) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (166...170) = "case"
        │   └── end_keyword_loc: (184...187) = "end"
        ├── @ CaseNode (location: (189...211))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (194...196))
        │   │   ├── opening_loc: (194...195) = ":"
        │   │   ├── value_loc: (195...196) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (197...206))
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (201...206))
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (201...202))
        │   │       │   │   └── flags: decimal
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (205...206))
        │   │       │   │   └── flags: decimal
        │   │       │   ├── operator_loc: (202...205) = "..."
        │   │       │   └── flags: exclude_end
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (197...199) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (189...193) = "case"
        │   └── end_keyword_loc: (208...211) = "end"
        ├── @ CaseNode (location: (213...232))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (218...220))
        │   │   ├── opening_loc: (218...219) = ":"
        │   │   ├── value_loc: (219...220) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (221...227))
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (225...227))
        │   │       │   └── flags: decimal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (221...223) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (213...217) = "case"
        │   └── end_keyword_loc: (229...232) = "end"
        ├── @ CaseNode (location: (234...254))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (239...241))
        │   │   ├── opening_loc: (239...240) = ":"
        │   │   ├── value_loc: (240...241) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (242...250))
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (245...250))
        │   │       │   ├── constant: ∅
        │   │       │   ├── assocs: (length: 1)
        │   │       │   │   └── @ NoKeywordsParameterNode (location: (245...250))
        │   │       │   │       ├── operator_loc: (245...247) = "**"
        │   │       │   │       └── keyword_loc: (247...250) = "nil"
        │   │       │   ├── kwrest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (242...244) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (234...238) = "case"
        │   └── end_keyword_loc: (251...254) = "end"
        ├── @ CaseNode (location: (256...279))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (261...263))
        │   │   ├── opening_loc: (261...262) = ":"
        │   │   ├── value_loc: (262...263) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (264...275))
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (267...275))
        │   │       │   ├── opening_loc: (267...268) = "/"
        │   │       │   ├── content_loc: (268...274) = "regexp"
        │   │       │   ├── closing_loc: (274...275) = "/"
        │   │       │   ├── unescaped: "regexp"
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (264...266) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (256...260) = "case"
        │   └── end_keyword_loc: (276...279) = "end"
        ├── @ CaseNode (location: (281...306))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (286...288))
        │   │   ├── opening_loc: (286...287) = ":"
        │   │   ├── value_loc: (287...288) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (289...302))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (292...302))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (292...294))
        │   │       │   │       ├── opening_loc: (292...293) = ":"
        │   │       │   │       ├── value_loc: (293...294) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (296...298))
        │   │       │   │   ├── operator_loc: (296...297) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (297...298))
        │   │       │   │       ├── name: :_
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (300...302))
        │   │       │   │       ├── opening_loc: (300...301) = ":"
        │   │       │   │       ├── value_loc: (301...302) = "c"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (289...291) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (281...285) = "case"
        │   └── end_keyword_loc: (303...306) = "end"
        ├── @ CaseNode (location: (308...331))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (313...315))
        │   │   ├── opening_loc: (313...314) = ":"
        │   │   ├── value_loc: (314...315) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (316...327))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (319...327))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (319...321))
        │   │       │   │   │   ├── opening_loc: (319...320) = ":"
        │   │       │   │   │   ├── value_loc: (320...321) = "b"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "b"
        │   │       │   │   └── @ ArrayPatternNode (location: (323...327))
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 1)
        │   │       │   │       │   └── @ SymbolNode (location: (324...326))
        │   │       │   │       │       ├── opening_loc: (324...325) = ":"
        │   │       │   │       │       ├── value_loc: (325...326) = "c"
        │   │       │   │       │       ├── closing_loc: ∅
        │   │       │   │       │       └── unescaped: "c"
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── posts: (length: 0)
        │   │       │   │       ├── opening_loc: (323...324) = "["
        │   │       │   │       └── closing_loc: (326...327) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (316...318) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (308...312) = "case"
        │   └── end_keyword_loc: (328...331) = "end"
        ├── @ CaseNode (location: (333...356))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (338...340))
        │   │   ├── opening_loc: (338...339) = ":"
        │   │   ├── value_loc: (339...340) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (341...352))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (344...352))
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (344...350))
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (350...351) = "("
        │   │       │   └── closing_loc: (351...352) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (341...343) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (333...337) = "case"
        │   └── end_keyword_loc: (353...356) = "end"
        ├── @ CaseNode (location: (358...394))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (363...365))
        │   │   ├── opening_loc: (363...364) = ":"
        │   │   ├── value_loc: (364...365) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (366...390))
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (369...390))
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (369...375))
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (376...380))
        │   │       │   │   ├── operator_loc: (376...377) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (377...380))
        │   │       │   │       ├── name: :lhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (382...383))
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (385...389))
        │   │       │   │   ├── operator_loc: (385...386) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (386...389))
        │   │       │   │       ├── name: :rhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (375...376) = "("
        │   │       │   └── closing_loc: (389...390) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (366...368) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (358...362) = "case"
        │   └── end_keyword_loc: (391...394) = "end"
        ├── @ CaseNode (location: (396...432))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (401...403))
        │   │   ├── opening_loc: (401...402) = ":"
        │   │   ├── value_loc: (402...403) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (404...428))
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (407...428))
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (407...413))
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (414...418))
        │   │       │   │   ├── operator_loc: (414...415) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (415...418))
        │   │       │   │       ├── name: :lhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (420...421))
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (423...427))
        │   │       │   │   ├── operator_loc: (423...424) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (424...427))
        │   │       │   │       ├── name: :rhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (413...414) = "["
        │   │       │   └── closing_loc: (427...428) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (404...406) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (396...400) = "case"
        │   └── end_keyword_loc: (429...432) = "end"
        ├── @ CaseNode (location: (434...468))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (439...441))
        │   │   ├── opening_loc: (439...440) = ":"
        │   │   ├── value_loc: (440...441) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (442...464))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (445...464))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LambdaNode (location: (446...460))
        │   │       │   │   │   ├── locals: [:b]
        │   │       │   │   │   ├── operator_loc: (446...448) = "->"
        │   │       │   │   │   ├── opening_loc: (452...453) = "{"
        │   │       │   │   │   ├── closing_loc: (459...460) = "}"
        │   │       │   │   │   ├── parameters:
        │   │       │   │   │   │   @ BlockParametersNode (location: (448...451))
        │   │       │   │   │   │   ├── parameters:
        │   │       │   │   │   │   │   @ ParametersNode (location: (449...450))
        │   │       │   │   │   │   │   ├── requireds: (length: 1)
        │   │       │   │   │   │   │   │   └── @ RequiredParameterNode (location: (449...450))
        │   │       │   │   │   │   │   │       └── name: :b
        │   │       │   │   │   │   │   ├── optionals: (length: 0)
        │   │       │   │   │   │   │   ├── rest: ∅
        │   │       │   │   │   │   │   ├── posts: (length: 0)
        │   │       │   │   │   │   │   ├── keywords: (length: 0)
        │   │       │   │   │   │   │   ├── keyword_rest: ∅
        │   │       │   │   │   │   │   └── block: ∅
        │   │       │   │   │   │   ├── locals: (length: 0)
        │   │       │   │   │   │   ├── opening_loc: (448...449) = "("
        │   │       │   │   │   │   └── closing_loc: (450...451) = ")"
        │   │       │   │   │   └── body:
        │   │       │   │   │       @ StatementsNode (location: (454...458))
        │   │       │   │   │       └── body: (length: 1)
        │   │       │   │   │           └── @ TrueNode (location: (454...458))
        │   │       │   │   └── @ LocalVariableTargetNode (location: (462...463))
        │   │       │   │       ├── name: :c
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (445...446) = "["
        │   │       │   └── closing_loc: (463...464) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (442...444) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (434...438) = "case"
        │   └── end_keyword_loc: (465...468) = "end"
        ├── @ CaseNode (location: (470...510))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (475...477))
        │   │   ├── opening_loc: (475...476) = ":"
        │   │   ├── value_loc: (476...477) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (478...506))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (481...506))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 4)
        │   │       │   │   ├── @ SymbolNode (location: (482...484))
        │   │       │   │   │   ├── opening_loc: (482...483) = ":"
        │   │       │   │   │   ├── value_loc: (483...484) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (486...487))
        │   │       │   │   │   ├── name: :b
        │   │       │   │   │   └── depth: 0
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (489...490))
        │   │       │   │   │   ├── name: :c
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ ArrayPatternNode (location: (492...505))
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 1)
        │   │       │   │       │   └── @ SymbolNode (location: (493...495))
        │   │       │   │       │       ├── opening_loc: (493...494) = ":"
        │   │       │   │       │       ├── value_loc: (494...495) = "d"
        │   │       │   │       │       ├── closing_loc: ∅
        │   │       │   │       │       └── unescaped: "d"
        │   │       │   │       ├── rest:
        │   │       │   │       │   @ SplatNode (location: (497...499))
        │   │       │   │       │   ├── operator_loc: (497...498) = "*"
        │   │       │   │       │   └── expression:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (498...499))
        │   │       │   │       │       ├── name: :e
        │   │       │   │       │       └── depth: 0
        │   │       │   │       ├── posts: (length: 1)
        │   │       │   │       │   └── @ NilNode (location: (501...504))
        │   │       │   │       ├── opening_loc: (492...493) = "["
        │   │       │   │       └── closing_loc: (504...505) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (481...482) = "["
        │   │       │   └── closing_loc: (505...506) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (478...480) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (470...474) = "case"
        │   └── end_keyword_loc: (507...510) = "end"
        ├── @ CaseNode (location: (512...536))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (517...519))
        │   │   ├── opening_loc: (517...518) = ":"
        │   │   ├── value_loc: (518...519) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (520...532))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (523...532))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ ConstantReadNode (location: (524...525))
        │   │       │   │       └── name: :A
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (527...528))
        │   │       │   │   ├── operator_loc: (527...528) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ ConstantReadNode (location: (530...531))
        │   │       │   │       └── name: :B
        │   │       │   ├── opening_loc: (523...524) = "["
        │   │       │   └── closing_loc: (531...532) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (520...522) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (512...516) = "case"
        │   └── end_keyword_loc: (533...536) = "end"
        ├── @ CaseNode (location: (538...572))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (543...545))
        │   │   ├── opening_loc: (543...544) = ":"
        │   │   ├── value_loc: (544...545) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (546...568))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (549...568))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ ArrayPatternNode (location: (550...557))
        │   │       │   │   │   ├── constant: ∅
        │   │       │   │   │   ├── requireds: (length: 2)
        │   │       │   │   │   │   ├── @ SymbolNode (location: (551...553))
        │   │       │   │   │   │   │   ├── opening_loc: (551...552) = ":"
        │   │       │   │   │   │   │   ├── value_loc: (552...553) = "b"
        │   │       │   │   │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   │   │   └── unescaped: "b"
        │   │       │   │   │   │   └── @ LocalVariableTargetNode (location: (555...556))
        │   │       │   │   │   │       ├── name: :c
        │   │       │   │   │   │       └── depth: 0
        │   │       │   │   │   ├── rest: ∅
        │   │       │   │   │   ├── posts: (length: 0)
        │   │       │   │   │   ├── opening_loc: (550...551) = "["
        │   │       │   │   │   └── closing_loc: (556...557) = "]"
        │   │       │   │   └── @ ArrayPatternNode (location: (559...567))
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 2)
        │   │       │   │       │   ├── @ SymbolNode (location: (560...562))
        │   │       │   │       │   │   ├── opening_loc: (560...561) = ":"
        │   │       │   │       │   │   ├── value_loc: (561...562) = "d"
        │   │       │   │       │   │   ├── closing_loc: ∅
        │   │       │   │       │   │   └── unescaped: "d"
        │   │       │   │       │   └── @ PinnedVariableNode (location: (564...566))
        │   │       │   │       │       ├── variable:
        │   │       │   │       │       │   @ LocalVariableReadNode (location: (565...566))
        │   │       │   │       │       │   ├── name: :e
        │   │       │   │       │       │   └── depth: 0
        │   │       │   │       │       └── operator_loc: (564...565) = "^"
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── posts: (length: 0)
        │   │       │   │       ├── opening_loc: (559...560) = "["
        │   │       │   │       └── closing_loc: (566...567) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (549...550) = "["
        │   │       │   └── closing_loc: (567...568) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (546...548) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (538...542) = "case"
        │   └── end_keyword_loc: (569...572) = "end"
        ├── @ CaseNode (location: (574...591))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (579...581))
        │   │   ├── opening_loc: (579...580) = ":"
        │   │   ├── value_loc: (580...581) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (582...587))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (585...587))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (585...586) = "["
        │   │       │   └── closing_loc: (586...587) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (582...584) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (574...578) = "case"
        │   └── end_keyword_loc: (588...591) = "end"
        ├── @ CaseNode (location: (593...614))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (598...600))
        │   │   ├── opening_loc: (598...599) = ":"
        │   │   ├── value_loc: (599...600) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (601...610))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (604...610))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ PinnedExpressionNode (location: (605...609))
        │   │       │   │       ├── expression:
        │   │       │   │       │   @ CallNode (location: (607...608))
        │   │       │   │       │   ├── receiver: ∅
        │   │       │   │       │   ├── call_operator_loc: ∅
        │   │       │   │       │   ├── message_loc: (607...608) = "a"
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── arguments: ∅
        │   │       │   │       │   ├── closing_loc: ∅
        │   │       │   │       │   ├── block: ∅
        │   │       │   │       │   ├── flags: variable_call
        │   │       │   │       │   └── name: "a"
        │   │       │   │       ├── operator_loc: (605...606) = "^"
        │   │       │   │       ├── lparen_loc: (606...607) = "("
        │   │       │   │       └── rparen_loc: (608...609) = ")"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (604...605) = "["
        │   │       │   └── closing_loc: (609...610) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (601...603) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (593...597) = "case"
        │   └── end_keyword_loc: (611...614) = "end"
        ├── @ CaseNode (location: (616...647))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (621...623))
        │   │   ├── opening_loc: (621...622) = ":"
        │   │   ├── value_loc: (622...623) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (624...643))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (627...643))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 3)
        │   │       │   │   ├── @ PinnedVariableNode (location: (628...631))
        │   │       │   │   │   ├── variable:
        │   │       │   │   │   │   @ InstanceVariableReadNode (location: (629...631))
        │   │       │   │   │   │   └── name: :@a
        │   │       │   │   │   └── operator_loc: (628...629) = "^"
        │   │       │   │   ├── @ PinnedVariableNode (location: (633...636))
        │   │       │   │   │   ├── variable:
        │   │       │   │   │   │   @ GlobalVariableReadNode (location: (634...636))
        │   │       │   │   │   │   └── name: :$b
        │   │       │   │   │   └── operator_loc: (633...634) = "^"
        │   │       │   │   └── @ PinnedVariableNode (location: (638...642))
        │   │       │   │       ├── variable:
        │   │       │   │       │   @ ClassVariableReadNode (location: (639...642))
        │   │       │   │       │   └── name: :@@c
        │   │       │   │       └── operator_loc: (638...639) = "^"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (627...628) = "["
        │   │       │   └── closing_loc: (642...643) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (624...626) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (616...620) = "case"
        │   └── end_keyword_loc: (644...647) = "end"
        ├── @ CaseNode (location: (649...673))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (654...656))
        │   │   ├── opening_loc: (654...655) = ":"
        │   │   ├── value_loc: (655...656) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (657...669))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (660...669))
        │   │       │   ├── opening_loc: (660...661) = "`"
        │   │       │   ├── content_loc: (661...668) = "echo hi"
        │   │       │   ├── closing_loc: (668...669) = "`"
        │   │       │   └── unescaped: "echo hi"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (657...659) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (649...653) = "case"
        │   └── end_keyword_loc: (670...673) = "end"
        ├── @ CaseNode (location: (675...703))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (680...682))
        │   │   ├── opening_loc: (680...681) = ":"
        │   │   ├── value_loc: (681...682) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (683...699))
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (686...699))
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 3)
        │   │       │   │   ├── @ NilNode (location: (686...689))
        │   │       │   │   ├── @ NilNode (location: (691...694))
        │   │       │   │   └── @ NilNode (location: (696...699))
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (683...685) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (675...679) = "case"
        │   └── end_keyword_loc: (700...703) = "end"
        ├── @ CaseNode (location: (705...728))
        │   ├── predicate:
        │   │   @ SymbolNode (location: (710...712))
        │   │   ├── opening_loc: (710...711) = ":"
        │   │   ├── value_loc: (711...712) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (713...724))
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (716...724))
        │   │       │   ├── constant: ∅
        │   │       │   ├── assocs: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (718...722))
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (718...722))
        │   │       │   │       │   ├── opening_loc: (718...719) = "\""
        │   │       │   │       │   ├── value_loc: (719...720) = "b"
        │   │       │   │       │   ├── closing_loc: (720...722) = "\":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value: ∅
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── kwrest: ∅
        │   │       │   ├── opening_loc: (716...717) = "{"
        │   │       │   └── closing_loc: (723...724) = "}"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (713...715) = "in"
        │   │       └── then_loc: ∅
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (705...709) = "case"
        │   └── end_keyword_loc: (725...728) = "end"
        └── @ CaseNode (location: (730...747))
            ├── predicate:
            │   @ SymbolNode (location: (735...737))
            │   ├── opening_loc: (735...736) = ":"
            │   ├── value_loc: (736...737) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (738...743))
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (741...743))
            │       │   ├── constant: ∅
            │       │   ├── assocs: (length: 0)
            │       │   ├── kwrest: ∅
            │       │   ├── opening_loc: (741...742) = "{"
            │       │   └── closing_loc: (742...743) = "}"
            │       ├── statements: ∅
            │       ├── in_loc: (738...740) = "in"
            │       └── then_loc: ∅
            ├── consequent: ∅
            ├── case_keyword_loc: (730...734) = "case"
            └── end_keyword_loc: (744...747) = "end"
