@ ProgramNode (location: (0...370))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...370))
    └── body: (length: 14)
        ├── @ ClassNode (location: (0...17))
        │   ├── locals: [:a]
        │   ├── class_keyword_loc: (0...5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (6...7))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (8...13))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (8...13))
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (8...9) = "a"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (12...13))
        │   │           │   └── flags: decimal
        │   │           └── operator_loc: (10...11) = "="
        │   ├── end_keyword_loc: (14...17) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (19...39))
        │   ├── locals: []
        │   ├── class_keyword_loc: (19...24) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (25...26))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (28...39))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (28...39))
        │   │   │   ├── ensure_keyword_loc: (28...34) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (36...39) = "end"
        │   │   └── end_keyword_loc: (36...39) = "end"
        │   ├── end_keyword_loc: (36...39) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (41...75))
        │   ├── locals: []
        │   ├── class_keyword_loc: (41...46) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (47...48))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (50...75))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (50...56))
        │   │   │   ├── keyword_loc: (50...56) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (58...70))
        │   │   │   ├── else_keyword_loc: (58...62) = "else"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (64...70) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (64...75))
        │   │   │   ├── ensure_keyword_loc: (64...70) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (72...75) = "end"
        │   │   └── end_keyword_loc: (72...75) = "end"
        │   ├── end_keyword_loc: (72...75) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (77...98))
        │   ├── locals: [:a]
        │   ├── class_keyword_loc: (77...82) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (83...84))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: (85...86) = "<"
        │   ├── superclass:
        │   │   @ ConstantReadNode (location: (87...88))
        │   │   └── name: :B
        │   ├── body:
        │   │   @ StatementsNode (location: (89...94))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (89...94))
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (89...90) = "a"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (93...94))
        │   │           │   └── flags: decimal
        │   │           └── operator_loc: (91...92) = "="
        │   ├── end_keyword_loc: (95...98) = "end"
        │   └── name: :A
        ├── @ SingletonClassNode (location: (100...120))
        │   ├── locals: []
        │   ├── class_keyword_loc: (100...105) = "class"
        │   ├── operator_loc: (106...108) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (109...116))
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (113...116))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (113...116) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (109...112) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: ∅
        │   │   └── name: "!"
        │   ├── body: ∅
        │   └── end_keyword_loc: (117...120) = "end"
        ├── @ ClassNode (location: (122...162))
        │   ├── locals: []
        │   ├── class_keyword_loc: (122...127) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (128...129))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (131...157))
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (131...157))
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (131...136) = "class"
        │   │           ├── operator_loc: (137...139) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (140...144))
        │   │           ├── body:
        │   │           │   @ BeginNode (location: (146...157))
        │   │           │   ├── begin_keyword_loc: ∅
        │   │           │   ├── statements: ∅
        │   │           │   ├── rescue_clause: ∅
        │   │           │   ├── else_clause: ∅
        │   │           │   ├── ensure_clause:
        │   │           │   │   @ EnsureNode (location: (146...157))
        │   │           │   │   ├── ensure_keyword_loc: (146...152) = "ensure"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (154...157) = "end"
        │   │           │   └── end_keyword_loc: (154...157) = "end"
        │   │           └── end_keyword_loc: (154...157) = "end"
        │   ├── end_keyword_loc: (159...162) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (164...218))
        │   ├── locals: []
        │   ├── class_keyword_loc: (164...169) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (170...171))
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (173...213))
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (173...213))
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (173...178) = "class"
        │   │           ├── operator_loc: (179...181) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (182...186))
        │   │           ├── body:
        │   │           │   @ BeginNode (location: (188...213))
        │   │           │   ├── begin_keyword_loc: ∅
        │   │           │   ├── statements: ∅
        │   │           │   ├── rescue_clause:
        │   │           │   │   @ RescueNode (location: (188...194))
        │   │           │   │   ├── keyword_loc: (188...194) = "rescue"
        │   │           │   │   ├── exceptions: (length: 0)
        │   │           │   │   ├── operator_loc: ∅
        │   │           │   │   ├── reference: ∅
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── consequent: ∅
        │   │           │   ├── else_clause:
        │   │           │   │   @ ElseNode (location: (196...208))
        │   │           │   │   ├── else_keyword_loc: (196...200) = "else"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (202...208) = "ensure"
        │   │           │   ├── ensure_clause:
        │   │           │   │   @ EnsureNode (location: (202...213))
        │   │           │   │   ├── ensure_keyword_loc: (202...208) = "ensure"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (210...213) = "end"
        │   │           │   └── end_keyword_loc: (210...213) = "end"
        │   │           └── end_keyword_loc: (210...213) = "end"
        │   ├── end_keyword_loc: (215...218) = "end"
        │   └── name: :A
        ├── @ SingletonClassNode (location: (220...240))
        │   ├── locals: []
        │   ├── class_keyword_loc: (220...225) = "class"
        │   ├── operator_loc: (226...228) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (229...236))
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (229...232))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (229...232) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── call_operator_loc: (232...233) = "."
        │   │   ├── message_loc: (233...236) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: ∅
        │   │   └── name: "bar"
        │   ├── body: ∅
        │   └── end_keyword_loc: (237...240) = "end"
        ├── @ SingletonClassNode (location: (242...262))
        │   ├── locals: []
        │   ├── class_keyword_loc: (242...247) = "class"
        │   ├── operator_loc: (248...250) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (251...258))
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (251...254))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (251...254) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── call_operator_loc: (254...255) = "."
        │   │   ├── message_loc: (255...258) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: ∅
        │   │   └── name: "bar"
        │   ├── body: ∅
        │   └── end_keyword_loc: (259...262) = "end"
        ├── @ SingletonClassNode (location: (264...281))
        │   ├── locals: []
        │   ├── class_keyword_loc: (264...269) = "class"
        │   ├── operator_loc: (270...272) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (273...277))
        │   ├── body: ∅
        │   └── end_keyword_loc: (278...281) = "end"
        ├── @ SingletonClassNode (location: (283...300))
        │   ├── locals: []
        │   ├── class_keyword_loc: (283...288) = "class"
        │   ├── operator_loc: (289...291) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (292...296))
        │   ├── body: ∅
        │   └── end_keyword_loc: (297...300) = "end"
        ├── @ SingletonClassNode (location: (302...325))
        │   ├── locals: []
        │   ├── class_keyword_loc: (302...307) = "class"
        │   ├── operator_loc: (308...310) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (311...315))
        │   ├── body:
        │   │   @ StatementsNode (location: (316...321))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (316...321))
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (316...317))
        │   │           │   └── flags: decimal
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (318...319) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (320...321))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (320...321))
        │   │           │           └── flags: decimal
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "+"
        │   └── end_keyword_loc: (322...325) = "end"
        ├── @ SingletonClassNode (location: (327...350))
        │   ├── locals: []
        │   ├── class_keyword_loc: (327...332) = "class"
        │   ├── operator_loc: (333...335) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (336...340))
        │   ├── body:
        │   │   @ StatementsNode (location: (341...346))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (341...346))
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (341...342))
        │   │           │   └── flags: decimal
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (343...344) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (345...346))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (345...346))
        │   │           │           └── flags: decimal
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "+"
        │   └── end_keyword_loc: (347...350) = "end"
        └── @ ClassNode (location: (352...370))
            ├── locals: []
            ├── class_keyword_loc: (352...357) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (358...359))
            │   └── name: :A
            ├── inheritance_operator_loc: (360...361) = "<"
            ├── superclass:
            │   @ CallNode (location: (362...366))
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (362...363))
            │   │   └── name: :B
            │   ├── call_operator_loc: ∅
            │   ├── message_loc: (363...366) = "[1]"
            │   ├── opening_loc: (363...364) = "["
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (364...365))
            │   │   └── arguments: (length: 1)
            │   │       └── @ IntegerNode (location: (364...365))
            │   │           └── flags: decimal
            │   ├── closing_loc: (365...366) = "]"
            │   ├── block: ∅
            │   ├── flags: ∅
            │   └── name: "[]"
            ├── body: ∅
            ├── end_keyword_loc: (367...370) = "end"
            └── name: :A
