@ ProgramNode (location: (0...233))
├── locals: [:a, :h]
└── statements:
    @ StatementsNode (location: (0...233))
    └── body: (length: 24)
        ├── @ LocalVariableOperatorWriteNode (location: (0...6))
        │   ├── name_loc: (0...1) = "a"
        │   ├── operator_loc: (2...4) = "+="
        │   ├── value:
        │   │   @ IntegerNode (location: (5...6))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   ├── operator: :+
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (7...13))
        │   ├── name_loc: (7...8) = "a"
        │   ├── operator_loc: (9...11) = "-="
        │   ├── value:
        │   │   @ IntegerNode (location: (12...13))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   ├── operator: :-
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (14...21))
        │   ├── name_loc: (14...15) = "a"
        │   ├── operator_loc: (16...19) = "**="
        │   ├── value:
        │   │   @ IntegerNode (location: (20...21))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   ├── operator: :**
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (22...28))
        │   ├── name_loc: (22...23) = "a"
        │   ├── operator_loc: (24...26) = "*="
        │   ├── value:
        │   │   @ IntegerNode (location: (27...28))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   ├── operator: :*
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (29...35))
        │   ├── name_loc: (29...30) = "a"
        │   ├── operator_loc: (31...33) = "/="
        │   ├── value:
        │   │   @ IntegerNode (location: (34...35))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   ├── operator: :/
        │   └── depth: 0
        ├── @ LocalVariableAndWriteNode (location: (36...43))
        │   ├── name_loc: (36...37) = "a"
        │   ├── operator_loc: (38...41) = "&&="
        │   ├── value:
        │   │   @ CallNode (location: (42...43))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (42...43) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "b"
        │   ├── name: :a
        │   └── depth: 0
        ├── @ LocalVariableOrWriteNode (location: (44...51))
        │   ├── name_loc: (44...45) = "a"
        │   ├── operator_loc: (46...49) = "||="
        │   ├── value:
        │   │   @ IntegerNode (location: (50...51))
        │   │   └── flags: decimal
        │   ├── name: :a
        │   └── depth: 0
        ├── @ CallNode (location: (52...65))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (52...61))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (53...60))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOrWriteNode (location: (53...60))
        │   │   │           ├── name_loc: (53...54) = "a"
        │   │   │           ├── operator_loc: (55...58) = "||="
        │   │   │           ├── value:
        │   │   │           │   @ IntegerNode (location: (59...60))
        │   │   │           │   └── flags: decimal
        │   │   │           ├── name: :a
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (52...53) = "("
        │   │   └── closing_loc: (60...61) = ")"
        │   ├── call_operator_loc: (61...62) = "."
        │   ├── message_loc: (62...65) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (66...83))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (66...76))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (67...75))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOrWriteNode (location: (67...75))
        │   │   │           ├── name_loc: (67...68) = "h"
        │   │   │           ├── operator_loc: (69...72) = "||="
        │   │   │           ├── value:
        │   │   │           │   @ HashNode (location: (73...75))
        │   │   │           │   ├── opening_loc: (73...74) = "{"
        │   │   │           │   ├── elements: (length: 0)
        │   │   │           │   └── closing_loc: (74...75) = "}"
        │   │   │           ├── name: :h
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (66...67) = "("
        │   │   └── closing_loc: (75...76) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (76...79) = "[k]"
        │   ├── opening_loc: (76...77) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (77...83))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (77...78))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (77...78) = "k"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "k"
        │   │       └── @ CallNode (location: (82...83))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (82...83) = "v"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "v"
        │   ├── closing_loc: (78...79) = "]"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]="
        ├── @ CallOperatorWriteNode (location: (84...92))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (84...85))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (85...86) = "."
        │   ├── message_loc: (86...87) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator: :+
        │   ├── operator_loc: (88...90) = "+="
        │   └── value:
        │       @ IntegerNode (location: (91...92))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (93...101))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (93...94))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (94...95) = "."
        │   ├── message_loc: (95...96) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator: :-
        │   ├── operator_loc: (97...99) = "-="
        │   └── value:
        │       @ IntegerNode (location: (100...101))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (102...111))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (102...103))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (103...104) = "."
        │   ├── message_loc: (104...105) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator: :**
        │   ├── operator_loc: (106...109) = "**="
        │   └── value:
        │       @ IntegerNode (location: (110...111))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (112...120))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (112...113))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (113...114) = "."
        │   ├── message_loc: (114...115) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator: :*
        │   ├── operator_loc: (116...118) = "*="
        │   └── value:
        │       @ IntegerNode (location: (119...120))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (121...129))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (121...122))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (122...123) = "."
        │   ├── message_loc: (123...124) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator: :/
        │   ├── operator_loc: (125...127) = "/="
        │   └── value:
        │       @ IntegerNode (location: (128...129))
        │       └── flags: decimal
        ├── @ CallAndWriteNode (location: (130...139))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (130...131))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (131...132) = "."
        │   ├── message_loc: (132...133) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator_loc: (134...137) = "&&="
        │   └── value:
        │       @ CallNode (location: (138...139))
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── message_loc: (138...139) = "b"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       ├── block: ∅
        │       ├── flags: variable_call
        │       └── name: "b"
        ├── @ CallOrWriteNode (location: (140...149))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (140...141))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (141...142) = "."
        │   ├── message_loc: (142...143) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── flags: ∅
        │   ├── read_name: "b"
        │   ├── write_name: "b="
        │   ├── operator_loc: (144...147) = "||="
        │   └── value:
        │       @ IntegerNode (location: (148...149))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (150...159))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (150...151))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (151...154) = "[b]"
        │   ├── opening_loc: (151...152) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (152...153))
        │   │   └── arguments: (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"
        │   ├── closing_loc: (153...154) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator: :+
        │   ├── operator_loc: (155...157) = "+="
        │   └── value:
        │       @ IntegerNode (location: (158...159))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (160...169))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (160...161))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (161...164) = "[b]"
        │   ├── opening_loc: (161...162) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (162...163))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (162...163))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (162...163) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (163...164) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator: :-
        │   ├── operator_loc: (165...167) = "-="
        │   └── value:
        │       @ IntegerNode (location: (168...169))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (170...180))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (170...171))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (171...174) = "[b]"
        │   ├── opening_loc: (171...172) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (172...173))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (172...173))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (172...173) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (173...174) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator: :**
        │   ├── operator_loc: (175...178) = "**="
        │   └── value:
        │       @ IntegerNode (location: (179...180))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (181...190))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (181...182))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (182...185) = "[b]"
        │   ├── opening_loc: (182...183) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (183...184))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (183...184))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (183...184) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (184...185) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator: :*
        │   ├── operator_loc: (186...188) = "*="
        │   └── value:
        │       @ IntegerNode (location: (189...190))
        │       └── flags: decimal
        ├── @ CallOperatorWriteNode (location: (191...200))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (191...192))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (192...195) = "[b]"
        │   ├── opening_loc: (192...193) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (193...194))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (193...194))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (193...194) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (194...195) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator: :/
        │   ├── operator_loc: (196...198) = "/="
        │   └── value:
        │       @ IntegerNode (location: (199...200))
        │       └── flags: decimal
        ├── @ CallAndWriteNode (location: (201...211))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (201...202))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (202...205) = "[b]"
        │   ├── opening_loc: (202...203) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (203...204))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (203...204))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (203...204) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (204...205) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator_loc: (206...209) = "&&="
        │   └── value:
        │       @ CallNode (location: (210...211))
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── message_loc: (210...211) = "b"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       ├── block: ∅
        │       ├── flags: variable_call
        │       └── name: "b"
        ├── @ CallOrWriteNode (location: (212...222))
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (212...213))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (213...216) = "[b]"
        │   ├── opening_loc: (213...214) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (214...215))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (214...215))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (214...215) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (215...216) = "]"
        │   ├── flags: ∅
        │   ├── read_name: "[]"
        │   ├── write_name: "[]="
        │   ├── operator_loc: (217...220) = "||="
        │   └── value:
        │       @ IntegerNode (location: (221...222))
        │       └── flags: decimal
        └── @ CallOperatorWriteNode (location: (223...233))
            ├── receiver:
            │   @ CallNode (location: (223...226))
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── message_loc: (223...226) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── block: ∅
            │   ├── flags: variable_call
            │   └── name: "foo"
            ├── call_operator_loc: (226...227) = "."
            ├── message_loc: (227...228) = "A"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            ├── flags: ∅
            ├── read_name: "A"
            ├── write_name: "A="
            ├── operator: :+
            ├── operator_loc: (229...231) = "+="
            └── value:
                @ IntegerNode (location: (232...233))
                └── flags: decimal
