@ ProgramNode (location: (1,0)-(54,17))
├── locals: [:fork]
└── statements:
    @ StatementsNode (location: (1,0)-(54,17))
    └── body: (length: 20)
        ├── @ CallNode (location: (1,0)-(1,16))
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: :foo
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1,3)-(1,8) = "[bar]"
        │   ├── opening_loc: (1,3)-(1,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,7))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (1,4)-(1,7))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (1,4)-(1,7) = "bar"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block: ∅
        │   │   │       ├── flags: variable_call
        │   │   │       └── name: :bar
        │   │   └── flags: ∅
        │   ├── closing_loc: (1,7)-(1,8) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (1,9)-(1,16))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (1,11)-(1,14))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,11)-(1,14))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (1,11)-(1,14) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: :baz
        │   │   ├── opening_loc: (1,9)-(1,10) = "{"
        │   │   └── closing_loc: (1,15)-(1,16) = "}"
        │   ├── flags: ∅
        │   └── name: :[]
        ├── @ CallNode (location: (3,0)-(5,3))
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: :foo
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (3,3)-(3,8) = "[bar]"
        │   ├── opening_loc: (3,3)-(3,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,7))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (3,4)-(3,7))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (3,4)-(3,7) = "bar"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block: ∅
        │   │   │       ├── flags: variable_call
        │   │   │       └── name: :bar
        │   │   └── flags: ∅
        │   ├── closing_loc: (3,7)-(3,8) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (3,9)-(5,3))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (4,0)-(4,3))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (4,0)-(4,3))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (4,0)-(4,3) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: :baz
        │   │   ├── opening_loc: (3,9)-(3,11) = "do"
        │   │   └── closing_loc: (5,0)-(5,3) = "end"
        │   ├── flags: ∅
        │   └── name: :[]
        ├── @ CallNode (location: (7,0)-(7,35))
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(7,1))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (7,0)-(7,1) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: :x
        │   ├── call_operator_loc: (7,1)-(7,2) = "."
        │   ├── message_loc: (7,2)-(7,8) = "reduce"
        │   ├── opening_loc: (7,8)-(7,9) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,9)-(7,10))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ IntegerNode (location: (7,9)-(7,10))
        │   │   │       └── flags: decimal
        │   │   └── flags: ∅
        │   ├── closing_loc: (7,10)-(7,11) = ")"
        │   ├── block:
        │   │   @ BlockNode (location: (7,12)-(7,35))
        │   │   ├── locals: [:x, :memo]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (7,14)-(7,23))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (7,15)-(7,22))
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ RequiredParameterNode (location: (7,15)-(7,16))
        │   │   │   │   │   │   └── name: :x
        │   │   │   │   │   └── @ RequiredParameterNode (location: (7,18)-(7,22))
        │   │   │   │   │       └── name: :memo
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (7,14)-(7,15) = "|"
        │   │   │   └── closing_loc: (7,22)-(7,23) = "|"
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (7,24)-(7,33))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOperatorWriteNode (location: (7,24)-(7,33))
        │   │   │           ├── name_loc: (7,24)-(7,28) = "memo"
        │   │   │           ├── operator_loc: (7,29)-(7,31) = "+="
        │   │   │           ├── value:
        │   │   │           │   @ LocalVariableReadNode (location: (7,32)-(7,33))
        │   │   │           │   ├── name: :x
        │   │   │           │   └── depth: 0
        │   │   │           ├── name: :memo
        │   │   │           ├── operator: :+
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (7,12)-(7,13) = "{"
        │   │   └── closing_loc: (7,34)-(7,35) = "}"
        │   ├── flags: ∅
        │   └── name: :reduce
        ├── @ CallNode (location: (9,0)-(9,10))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (9,4)-(9,10))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (9,4)-(9,6) = "do"
        │   │   └── closing_loc: (9,7)-(9,10) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (11,0)-(11,21))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,4)-(11,21))
        │   │   ├── arguments: (length: 2)
        │   │   │   ├── @ CallNode (location: (11,4)-(11,7))
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── message_loc: (11,4)-(11,7) = "bar"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   ├── block: ∅
        │   │   │   │   ├── flags: variable_call
        │   │   │   │   └── name: :bar
        │   │   │   └── @ ParenthesesNode (location: (11,9)-(11,21))
        │   │   │       ├── body:
        │   │   │       │   @ StatementsNode (location: (11,10)-(11,20))
        │   │   │       │   └── body: (length: 1)
        │   │   │       │       └── @ CallNode (location: (11,10)-(11,20))
        │   │   │       │           ├── receiver: ∅
        │   │   │       │           ├── call_operator_loc: ∅
        │   │   │       │           ├── message_loc: (11,10)-(11,13) = "baz"
        │   │   │       │           ├── opening_loc: ∅
        │   │   │       │           ├── arguments: ∅
        │   │   │       │           ├── closing_loc: ∅
        │   │   │       │           ├── block:
        │   │   │       │           │   @ BlockNode (location: (11,14)-(11,20))
        │   │   │       │           │   ├── locals: []
        │   │   │       │           │   ├── parameters: ∅
        │   │   │       │           │   ├── body: ∅
        │   │   │       │           │   ├── opening_loc: (11,14)-(11,16) = "do"
        │   │   │       │           │   └── closing_loc: (11,17)-(11,20) = "end"
        │   │   │       │           ├── flags: ∅
        │   │   │       │           └── name: :baz
        │   │   │       ├── opening_loc: (11,9)-(11,10) = "("
        │   │   │       └── closing_loc: (11,20)-(11,21) = ")"
        │   │   └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (13,0)-(13,14))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,4)-(13,7))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (13,4)-(13,7))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (13,4)-(13,7) = "bar"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block: ∅
        │   │   │       ├── flags: variable_call
        │   │   │       └── name: :bar
        │   │   └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (13,8)-(13,14))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (13,8)-(13,10) = "do"
        │   │   └── closing_loc: (13,11)-(13,14) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (15,0)-(15,18))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,4)-(15,11))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (15,4)-(15,11))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (15,4)-(15,7) = "bar"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments:
        │   │   │       │   @ ArgumentsNode (location: (15,8)-(15,11))
        │   │   │       │   ├── arguments: (length: 1)
        │   │   │       │   │   └── @ CallNode (location: (15,8)-(15,11))
        │   │   │       │   │       ├── receiver: ∅
        │   │   │       │   │       ├── call_operator_loc: ∅
        │   │   │       │   │       ├── message_loc: (15,8)-(15,11) = "baz"
        │   │   │       │   │       ├── opening_loc: ∅
        │   │   │       │   │       ├── arguments: ∅
        │   │   │       │   │       ├── closing_loc: ∅
        │   │   │       │   │       ├── block: ∅
        │   │   │       │   │       ├── flags: variable_call
        │   │   │       │   │       └── name: :baz
        │   │   │       │   └── flags: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block: ∅
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (15,12)-(15,18))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (15,12)-(15,14) = "do"
        │   │   └── closing_loc: (15,15)-(15,18) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (17,0)-(18,3))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (17,4)-(18,3))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (17,7)-(17,17))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (17,8)-(17,16))
        │   │   │   │   ├── requireds: (length: 0)
        │   │   │   │   ├── optionals: (length: 1)
        │   │   │   │   │   └── @ OptionalParameterNode (location: (17,8)-(17,16))
        │   │   │   │   │       ├── name: :a
        │   │   │   │   │       ├── name_loc: (17,8)-(17,9) = "a"
        │   │   │   │   │       ├── operator_loc: (17,10)-(17,11) = "="
        │   │   │   │   │       └── value:
        │   │   │   │   │           @ CallNode (location: (17,12)-(17,16))
        │   │   │   │   │           ├── receiver:
        │   │   │   │   │           │   @ CallNode (location: (17,12)-(17,13))
        │   │   │   │   │           │   ├── receiver: ∅
        │   │   │   │   │           │   ├── call_operator_loc: ∅
        │   │   │   │   │           │   ├── message_loc: (17,12)-(17,13) = "b"
        │   │   │   │   │           │   ├── opening_loc: ∅
        │   │   │   │   │           │   ├── arguments: ∅
        │   │   │   │   │           │   ├── closing_loc: ∅
        │   │   │   │   │           │   ├── block: ∅
        │   │   │   │   │           │   ├── flags: variable_call
        │   │   │   │   │           │   └── name: :b
        │   │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │   │           ├── message_loc: (17,13)-(17,16) = "[1]"
        │   │   │   │   │           ├── opening_loc: (17,13)-(17,14) = "["
        │   │   │   │   │           ├── arguments:
        │   │   │   │   │           │   @ ArgumentsNode (location: (17,14)-(17,15))
        │   │   │   │   │           │   ├── arguments: (length: 1)
        │   │   │   │   │           │   │   └── @ IntegerNode (location: (17,14)-(17,15))
        │   │   │   │   │           │   │       └── flags: decimal
        │   │   │   │   │           │   └── flags: ∅
        │   │   │   │   │           ├── closing_loc: (17,15)-(17,16) = "]"
        │   │   │   │   │           ├── block: ∅
        │   │   │   │   │           ├── flags: ∅
        │   │   │   │   │           └── name: :[]
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (17,7)-(17,8) = "|"
        │   │   │   └── closing_loc: (17,16)-(17,17) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (17,4)-(17,6) = "do"
        │   │   └── closing_loc: (18,0)-(18,3) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (20,0)-(22,3))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (20,4)-(22,3))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ BeginNode (location: (21,0)-(22,3))
        │   │   │   ├── begin_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   ├── rescue_clause:
        │   │   │   │   @ RescueNode (location: (21,0)-(21,6))
        │   │   │   │   ├── keyword_loc: (21,0)-(21,6) = "rescue"
        │   │   │   │   ├── exceptions: (length: 0)
        │   │   │   │   ├── operator_loc: ∅
        │   │   │   │   ├── reference: ∅
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── consequent: ∅
        │   │   │   ├── else_clause: ∅
        │   │   │   ├── ensure_clause: ∅
        │   │   │   └── end_keyword_loc: (22,0)-(22,3) = "end"
        │   │   ├── opening_loc: (20,4)-(20,6) = "do"
        │   │   └── closing_loc: (22,0)-(22,3) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (24,0)-(29,3))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (24,0)-(24,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (24,4)-(29,3))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (25,2)-(28,5))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (25,2)-(28,5))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (25,2)-(25,5) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block:
        │   │   │           │   @ BlockNode (location: (25,6)-(28,5))
        │   │   │           │   ├── locals: []
        │   │   │           │   ├── parameters: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (26,4)-(27,7))
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (26,4)-(27,7))
        │   │   │           │   │           ├── receiver: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── message_loc: (26,4)-(26,7) = "baz"
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments: ∅
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           ├── block:
        │   │   │           │   │           │   @ BlockNode (location: (26,8)-(27,7))
        │   │   │           │   │           │   ├── locals: []
        │   │   │           │   │           │   ├── parameters: ∅
        │   │   │           │   │           │   ├── body: ∅
        │   │   │           │   │           │   ├── opening_loc: (26,8)-(26,10) = "do"
        │   │   │           │   │           │   └── closing_loc: (27,4)-(27,7) = "end"
        │   │   │           │   │           ├── flags: ∅
        │   │   │           │   │           └── name: :baz
        │   │   │           │   ├── opening_loc: (25,6)-(25,8) = "do"
        │   │   │           │   └── closing_loc: (28,2)-(28,5) = "end"
        │   │   │           ├── flags: ∅
        │   │   │           └── name: :bar
        │   │   ├── opening_loc: (24,4)-(24,6) = "do"
        │   │   └── closing_loc: (29,0)-(29,3) = "end"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (31,0)-(31,16))
        │   ├── receiver:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: :foo
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (31,3)-(31,8) = "[bar]"
        │   ├── opening_loc: (31,3)-(31,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,4)-(31,7))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (31,4)-(31,7))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (31,4)-(31,7) = "bar"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block: ∅
        │   │   │       ├── flags: variable_call
        │   │   │       └── name: :bar
        │   │   └── flags: ∅
        │   ├── closing_loc: (31,7)-(31,8) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (31,9)-(31,16))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (31,11)-(31,14))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (31,11)-(31,14))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (31,11)-(31,14) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: :baz
        │   │   ├── opening_loc: (31,9)-(31,10) = "{"
        │   │   └── closing_loc: (31,15)-(31,16) = "}"
        │   ├── flags: ∅
        │   └── name: :[]
        ├── @ CallNode (location: (33,0)-(33,24))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (33,4)-(33,24))
        │   │   ├── locals: [:x, :y, :z]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (33,6)-(33,20))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (33,7)-(33,19))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (33,7)-(33,8))
        │   │   │   │   │       └── name: :x
        │   │   │   │   ├── optionals: (length: 1)
        │   │   │   │   │   └── @ OptionalParameterNode (location: (33,10)-(33,15))
        │   │   │   │   │       ├── name: :y
        │   │   │   │   │       ├── name_loc: (33,10)-(33,11) = "y"
        │   │   │   │   │       ├── operator_loc: (33,12)-(33,13) = "="
        │   │   │   │   │       └── value:
        │   │   │   │   │           @ IntegerNode (location: (33,14)-(33,15))
        │   │   │   │   │           └── flags: decimal
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 1)
        │   │   │   │   │   └── @ RequiredKeywordParameterNode (location: (33,17)-(33,19))
        │   │   │   │   │       ├── name: :z
        │   │   │   │   │       └── name_loc: (33,17)-(33,19) = "z:"
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (33,6)-(33,7) = "|"
        │   │   │   └── closing_loc: (33,19)-(33,20) = "|"
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (33,21)-(33,22))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (33,21)-(33,22))
        │   │   │           ├── name: :x
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (33,4)-(33,5) = "{"
        │   │   └── closing_loc: (33,23)-(33,24) = "}"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ CallNode (location: (35,0)-(35,11))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (35,4)-(35,11))
        │   │   ├── locals: [:x]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (35,6)-(35,9))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (35,7)-(35,8))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (35,7)-(35,8))
        │   │   │   │   │       └── name: :x
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (35,6)-(35,7) = "|"
        │   │   │   └── closing_loc: (35,8)-(35,9) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (35,4)-(35,5) = "{"
        │   │   └── closing_loc: (35,10)-(35,11) = "}"
        │   ├── flags: ∅
        │   └── name: :foo
        ├── @ LocalVariableWriteNode (location: (37,0)-(37,8))
        │   ├── name: :fork
        │   ├── depth: 0
        │   ├── name_loc: (37,0)-(37,4) = "fork"
        │   ├── value:
        │   │   @ IntegerNode (location: (37,7)-(37,8))
        │   │   └── flags: decimal
        │   └── operator_loc: (37,5)-(37,6) = "="
        ├── @ CallNode (location: (38,0)-(39,3))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (38,0)-(38,4) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (38,5)-(39,3))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (38,8)-(38,11))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (38,9)-(38,10))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (38,9)-(38,10))
        │   │   │   │   │       └── name: :a
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (38,8)-(38,9) = "|"
        │   │   │   └── closing_loc: (38,10)-(38,11) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (38,5)-(38,7) = "do"
        │   │   └── closing_loc: (39,0)-(39,3) = "end"
        │   ├── flags: ∅
        │   └── name: :fork
        ├── @ CallNode (location: (41,0)-(41,12))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (41,0)-(41,4) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (41,5)-(41,12))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (41,7)-(41,10))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (41,8)-(41,9))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (41,8)-(41,9))
        │   │   │   │   │       └── name: :a
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (41,7)-(41,8) = "|"
        │   │   │   └── closing_loc: (41,9)-(41,10) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (41,5)-(41,6) = "{"
        │   │   └── closing_loc: (41,11)-(41,12) = "}"
        │   ├── flags: ∅
        │   └── name: :fork
        ├── @ CallNode (location: (43,0)-(44,3))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (43,0)-(43,1) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (43,2)-(44,3))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (43,2)-(43,4) = "do"
        │   │   └── closing_loc: (44,0)-(44,3) = "end"
        │   ├── flags: ∅
        │   └── name: :C
        ├── @ CallNode (location: (46,0)-(46,4))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (46,0)-(46,1) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (46,2)-(46,4))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (46,2)-(46,3) = "{"
        │   │   └── closing_loc: (46,3)-(46,4) = "}"
        │   ├── flags: ∅
        │   └── name: :C
        ├── @ CallNode (location: (48,0)-(52,1))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,4)-(52,1))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ CallNode (location: (48,4)-(52,1))
        │   │   │       ├── receiver: ∅
        │   │   │       ├── call_operator_loc: ∅
        │   │   │       ├── message_loc: (48,4)-(48,10) = "lambda"
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── arguments: ∅
        │   │   │       ├── closing_loc: ∅
        │   │   │       ├── block:
        │   │   │       │   @ BlockNode (location: (48,11)-(52,1))
        │   │   │       │   ├── locals: [:a, :b]
        │   │   │       │   ├── parameters:
        │   │   │       │   │   @ BlockParametersNode (location: (48,13)-(51,3))
        │   │   │       │   │   ├── parameters:
        │   │   │       │   │   │   @ ParametersNode (location: (49,2)-(50,6))
        │   │   │       │   │   │   ├── requireds: (length: 0)
        │   │   │       │   │   │   ├── optionals: (length: 0)
        │   │   │       │   │   │   ├── rest: ∅
        │   │   │       │   │   │   ├── posts: (length: 0)
        │   │   │       │   │   │   ├── keywords: (length: 2)
        │   │   │       │   │   │   │   ├── @ OptionalKeywordParameterNode (location: (49,2)-(49,6))
        │   │   │       │   │   │   │   │   ├── name: :a
        │   │   │       │   │   │   │   │   ├── name_loc: (49,2)-(49,4) = "a:"
        │   │   │       │   │   │   │   │   └── value:
        │   │   │       │   │   │   │   │       @ IntegerNode (location: (49,5)-(49,6))
        │   │   │       │   │   │   │   │       └── flags: decimal
        │   │   │       │   │   │   │   └── @ OptionalKeywordParameterNode (location: (50,2)-(50,6))
        │   │   │       │   │   │   │       ├── name: :b
        │   │   │       │   │   │   │       ├── name_loc: (50,2)-(50,4) = "b:"
        │   │   │       │   │   │   │       └── value:
        │   │   │       │   │   │   │           @ IntegerNode (location: (50,5)-(50,6))
        │   │   │       │   │   │   │           └── flags: decimal
        │   │   │       │   │   │   ├── keyword_rest: ∅
        │   │   │       │   │   │   └── block: ∅
        │   │   │       │   │   ├── locals: (length: 0)
        │   │   │       │   │   ├── opening_loc: (48,13)-(48,14) = "|"
        │   │   │       │   │   └── closing_loc: (51,2)-(51,3) = "|"
        │   │   │       │   ├── body: ∅
        │   │   │       │   ├── opening_loc: (48,11)-(48,12) = "{"
        │   │   │       │   └── closing_loc: (52,0)-(52,1) = "}"
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :lambda
        │   │   └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: :foo
        └── @ CallNode (location: (54,0)-(54,17))
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── message_loc: (54,0)-(54,3) = "foo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            ├── block:
            │   @ BlockNode (location: (54,4)-(54,17))
            │   ├── locals: [:bar]
            │   ├── parameters:
            │   │   @ BlockParametersNode (location: (54,7)-(54,13))
            │   │   ├── parameters:
            │   │   │   @ ParametersNode (location: (54,8)-(54,12))
            │   │   │   ├── requireds: (length: 1)
            │   │   │   │   └── @ RequiredParameterNode (location: (54,8)-(54,11))
            │   │   │   │       └── name: :bar
            │   │   │   ├── optionals: (length: 0)
            │   │   │   ├── rest:
            │   │   │   │   @ RestParameterNode (location: (54,11)-(54,12))
            │   │   │   │   ├── name: ∅
            │   │   │   │   ├── name_loc: ∅
            │   │   │   │   └── operator_loc: (54,11)-(54,12) = ","
            │   │   │   ├── posts: (length: 0)
            │   │   │   ├── keywords: (length: 0)
            │   │   │   ├── keyword_rest: ∅
            │   │   │   └── block: ∅
            │   │   ├── locals: (length: 0)
            │   │   ├── opening_loc: (54,7)-(54,8) = "|"
            │   │   └── closing_loc: (54,12)-(54,13) = "|"
            │   ├── body: ∅
            │   ├── opening_loc: (54,4)-(54,6) = "do"
            │   └── closing_loc: (54,14)-(54,17) = "end"
            ├── flags: ∅
            └── name: :foo
