@ ProgramNode (location: (0...578))
├── locals: [:ex]
└── statements:
    @ StatementsNode (location: (0...578))
    └── body: (length: 17)
        ├── @ BeginNode (location: (0...33))
        │   ├── begin_keyword_loc: (0...5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (7...8))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7...8))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (7...8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (10...19))
        │   │   ├── keyword_loc: (10...16) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (18...19))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (18...19))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (18...19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (21...33))
        │   │   ├── else_keyword_loc: (21...25) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (27...28))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (27...28))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (27...28) = "c"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "c"
        │   │   └── end_keyword_loc: (30...33) = "end"
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (30...33) = "end"
        ├── @ BeginNode (location: (35...79))
        │   ├── begin_keyword_loc: (35...40) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (42...43))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (42...43))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (42...43) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (45...54))
        │   │   ├── keyword_loc: (45...51) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (53...54))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (53...54))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (53...54) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (56...71))
        │   │   ├── else_keyword_loc: (56...60) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (62...63))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (62...63))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (62...63) = "c"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "c"
        │   │   └── end_keyword_loc: (65...71) = "ensure"
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (65...79))
        │   │   ├── ensure_keyword_loc: (65...71) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (73...74))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (73...74))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (73...74) = "d"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "d"
        │   │   └── end_keyword_loc: (76...79) = "end"
        │   └── end_keyword_loc: (76...79) = "end"
        ├── @ BeginNode (location: (81...92))
        │   ├── begin_keyword_loc: (81...86) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (87...88))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (87...88))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (87...88) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (89...92) = "end"
        ├── @ BeginNode (location: (94...107))
        │   ├── begin_keyword_loc: (94...99) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (101...102))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (101...102))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (101...102) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (104...107) = "end"
        ├── @ BeginNode (location: (109...121))
        │   ├── begin_keyword_loc: (109...114) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (115...116))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (115...116))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (115...116) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (118...121) = "end"
        ├── @ BeginNode (location: (123...135))
        │   ├── begin_keyword_loc: (123...128) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (129...130))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (129...130))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (129...130) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (132...135) = "end"
        ├── @ BeginNode (location: (137...175))
        │   ├── begin_keyword_loc: (137...142) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (143...144))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (143...144))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (143...144) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (145...171))
        │   │   ├── keyword_loc: (145...151) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (152...153))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (152...153))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (152...153) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent:
        │   │       @ RescueNode (location: (154...171))
        │   │       ├── keyword_loc: (154...160) = "rescue"
        │   │       ├── exceptions: (length: 0)
        │   │       ├── operator_loc: ∅
        │   │       ├── reference: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (161...162))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (161...162))
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── message_loc: (161...162) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           ├── block: ∅
        │   │       │           ├── flags: variable_call
        │   │       │           └── name: "c"
        │   │       └── consequent:
        │   │           @ RescueNode (location: (163...171))
        │   │           ├── keyword_loc: (163...169) = "rescue"
        │   │           ├── exceptions: (length: 0)
        │   │           ├── operator_loc: ∅
        │   │           ├── reference: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (170...171))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (170...171))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (170...171) = "d"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "d"
        │   │           └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (172...175) = "end"
        ├── @ BeginNode (location: (177...269))
        │   ├── begin_keyword_loc: (177...182) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (185...186))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (185...186))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (185...186) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (187...265))
        │   │   ├── keyword_loc: (187...193) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (194...203))
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: (204...206) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (207...209))
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (212...213))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (212...213))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (212...213) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent:
        │   │       @ RescueNode (location: (214...265))
        │   │       ├── keyword_loc: (214...220) = "rescue"
        │   │       ├── exceptions: (length: 2)
        │   │       │   ├── @ ConstantReadNode (location: (221...237))
        │   │       │   │   └── name: :AnotherException
        │   │       │   └── @ ConstantReadNode (location: (239...255))
        │   │       │       └── name: :OneMoreException
        │   │       ├── operator_loc: (256...258) = "=>"
        │   │       ├── reference:
        │   │       │   @ LocalVariableTargetNode (location: (259...261))
        │   │       │   ├── name: :ex
        │   │       │   └── depth: 0
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (264...265))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (264...265))
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── message_loc: (264...265) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           ├── block: ∅
        │   │       │           ├── flags: variable_call
        │   │       │           └── name: "c"
        │   │       └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (266...269) = "end"
        ├── @ BeginNode (location: (271...322))
        │   ├── begin_keyword_loc: (271...276) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (279...280))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (279...280))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (279...280) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (281...307))
        │   │   ├── keyword_loc: (281...287) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (288...297))
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: (298...300) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (301...303))
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (306...307))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (306...307))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (306...307) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (308...322))
        │   │   ├── ensure_keyword_loc: (308...314) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (317...318))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (317...318))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (317...318) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── end_keyword_loc: (319...322) = "end"
        │   └── end_keyword_loc: (319...322) = "end"
        ├── @ StringNode (location: (324...330))
        │   ├── opening_loc: (324...326) = "%!"
        │   ├── content_loc: (326...329) = "abc"
        │   ├── closing_loc: (329...330) = "!"
        │   └── unescaped: "abc"
        ├── @ BeginNode (location: (332...352))
        │   ├── begin_keyword_loc: (332...337) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (338...339))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (338...339))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (338...339) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (340...348))
        │   │   ├── keyword_loc: (340...346) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (347...348))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (347...348))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (347...348) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (349...352) = "end"
        ├── @ BeginNode (location: (354...374))
        │   ├── begin_keyword_loc: (354...359) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (360...361))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (360...361))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (360...361) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (362...370))
        │   │   ├── keyword_loc: (362...368) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (369...370))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (369...370))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (369...370) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (371...374) = "end"
        ├── @ BeginNode (location: (376...396))
        │   ├── begin_keyword_loc: (376...381) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (382...383))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (382...383))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (382...383) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (384...392))
        │   │   ├── keyword_loc: (384...390) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (391...392))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (391...392))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (391...392) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (393...396) = "end"
        ├── @ BeginNode (location: (398...428))
        │   ├── begin_keyword_loc: (398...403) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (404...405))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (404...405))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (404...405) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (406...424))
        │   │   ├── keyword_loc: (406...412) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (413...422))
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (423...424))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (423...424))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (423...424) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (425...428) = "end"
        ├── @ BeginNode (location: (430...477))
        │   ├── begin_keyword_loc: (430...435) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (436...437))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (436...437))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (436...437) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (438...473))
        │   │   ├── keyword_loc: (438...444) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (445...454))
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (456...471))
        │   │   │       └── name: :CustomException
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (472...473))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (472...473))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (472...473) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (474...477) = "end"
        ├── @ BeginNode (location: (479...536))
        │   ├── begin_keyword_loc: (479...484) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (487...488))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (487...488))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (487...488) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (489...532))
        │   │   ├── keyword_loc: (489...495) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (496...505))
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (507...522))
        │   │   │       └── name: :CustomException
        │   │   ├── operator_loc: (523...525) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (526...528))
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (531...532))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (531...532))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (531...532) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (533...536) = "end"
        └── @ BeginNode (location: (538...578))
            ├── begin_keyword_loc: (538...543) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (546...547))
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (546...547))
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── message_loc: (546...547) = "a"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           ├── block: ∅
            │           ├── flags: variable_call
            │           └── name: "a"
            ├── rescue_clause:
            │   @ RescueNode (location: (548...574))
            │   ├── keyword_loc: (548...554) = "rescue"
            │   ├── exceptions: (length: 1)
            │   │   └── @ ConstantReadNode (location: (555...564))
            │   │       └── name: :Exception
            │   ├── operator_loc: (565...567) = "=>"
            │   ├── reference:
            │   │   @ LocalVariableTargetNode (location: (568...570))
            │   │   ├── name: :ex
            │   │   └── depth: 0
            │   ├── statements:
            │   │   @ StatementsNode (location: (573...574))
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (573...574))
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── message_loc: (573...574) = "b"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           ├── block: ∅
            │   │           ├── flags: variable_call
            │   │           └── name: "b"
            │   └── consequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (575...578) = "end"
