@ ProgramNode (location: (1,0)-(71,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(71,7))
    ├── flags: ∅
    └── body: (length: 35)
        ├── @ CallNode (location: (1,0)-(1,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (1,0)-(1,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,1)-(1,5))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,1)-(1,2) = "{"
        │       └── closing_loc: (1,4)-(1,5) = "}"
        ├── @ CallNode (location: (3,0)-(3,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (3,0)-(3,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,1)-(3,8))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (3,3)-(3,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (3,3)-(3,4) = "|"
        │       │   └── closing_loc: (3,5)-(3,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (3,1)-(3,2) = "{"
        │       └── closing_loc: (3,7)-(3,8) = "}"
        ├── @ CallNode (location: (5,0)-(5,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (5,0)-(5,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,1)-(5,9))
        │       ├── flags: ∅
        │       ├── locals: [:b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (5,3)-(5,7))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (5,4)-(5,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (5,4)-(5,6))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (5,5)-(5,6) = "b"
        │       │   │       └── operator_loc: (5,4)-(5,5) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (5,3)-(5,4) = "|"
        │       │   └── closing_loc: (5,6)-(5,7) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (5,1)-(5,2) = "{"
        │       └── closing_loc: (5,8)-(5,9) = "}"
        ├── @ CallNode (location: (7,0)-(7,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (7,0)-(7,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,1)-(7,16))
        │       ├── flags: ∅
        │       ├── locals: [:baz, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (7,3)-(7,14))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (7,4)-(7,13))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest:
        │       │   │   │   @ KeywordRestParameterNode (location: (7,4)-(7,9))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :baz
        │       │   │   │   ├── name_loc: (7,6)-(7,9) = "baz"
        │       │   │   │   └── operator_loc: (7,4)-(7,6) = "**"
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (7,11)-(7,13))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (7,12)-(7,13) = "b"
        │       │   │       └── operator_loc: (7,11)-(7,12) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (7,3)-(7,4) = "|"
        │       │   └── closing_loc: (7,13)-(7,14) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (7,1)-(7,2) = "{"
        │       └── closing_loc: (7,15)-(7,16) = "}"
        ├── @ CallNode (location: (9,0)-(9,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (9,0)-(9,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,1)-(9,12))
        │       ├── flags: ∅
        │       ├── locals: [:b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (9,3)-(9,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (9,4)-(9,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (9,4)-(9,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (9,4)-(9,5) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (9,7)-(9,9))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (9,8)-(9,9) = "b"
        │       │   │       └── operator_loc: (9,7)-(9,8) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (9,3)-(9,4) = "|"
        │       │   └── closing_loc: (9,9)-(9,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (9,1)-(9,2) = "{"
        │       └── closing_loc: (9,11)-(9,12) = "}"
        ├── @ CallNode (location: (11,0)-(11,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (11,0)-(11,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (11,1)-(11,16))
        │       ├── flags: ∅
        │       ├── locals: [:r, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (11,3)-(11,14))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (11,4)-(11,13))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (11,4)-(11,6))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (11,5)-(11,6) = "r"
        │       │   │   │   └── operator_loc: (11,4)-(11,5) = "*"
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (11,8)-(11,9))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (11,11)-(11,13))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (11,12)-(11,13) = "b"
        │       │   │       └── operator_loc: (11,11)-(11,12) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (11,3)-(11,4) = "|"
        │       │   └── closing_loc: (11,13)-(11,14) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (11,1)-(11,2) = "{"
        │       └── closing_loc: (11,15)-(11,16) = "}"
        ├── @ CallNode (location: (13,0)-(13,13))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (13,0)-(13,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,1)-(13,13))
        │       ├── flags: ∅
        │       ├── locals: [:s, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (13,3)-(13,11))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (13,4)-(13,10))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (13,4)-(13,6))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :s
        │       │   │   │   ├── name_loc: (13,5)-(13,6) = "s"
        │       │   │   │   └── operator_loc: (13,4)-(13,5) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (13,8)-(13,10))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (13,9)-(13,10) = "b"
        │       │   │       └── operator_loc: (13,8)-(13,9) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (13,3)-(13,4) = "|"
        │       │   └── closing_loc: (13,10)-(13,11) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (13,1)-(13,2) = "{"
        │       └── closing_loc: (13,12)-(13,13) = "}"
        ├── @ CallNode (location: (15,0)-(15,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (15,0)-(15,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (15,1)-(15,9))
        │       ├── flags: ∅
        │       ├── locals: [:s]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (15,3)-(15,7))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (15,4)-(15,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (15,4)-(15,6))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :s
        │       │   │   │   ├── name_loc: (15,5)-(15,6) = "s"
        │       │   │   │   └── operator_loc: (15,4)-(15,5) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (15,3)-(15,4) = "|"
        │       │   └── closing_loc: (15,6)-(15,7) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (15,1)-(15,2) = "{"
        │       └── closing_loc: (15,8)-(15,9) = "}"
        ├── @ CallNode (location: (17,0)-(17,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (17,0)-(17,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,1)-(17,8))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (17,3)-(17,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (17,4)-(17,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (17,4)-(17,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (17,4)-(17,5) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (17,3)-(17,4) = "|"
        │       │   └── closing_loc: (17,5)-(17,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (17,1)-(17,2) = "{"
        │       └── closing_loc: (17,7)-(17,8) = "}"
        ├── @ CallNode (location: (19,0)-(21,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (19,0)-(19,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,1)-(21,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (19,3)-(21,1))
        │       │   ├── flags: ∅
        │       │   ├── parameters: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (20,0)-(20,1))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :a
        │       │   ├── opening_loc: (19,3)-(19,4) = "|"
        │       │   └── closing_loc: (21,0)-(21,1) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (19,1)-(19,2) = "{"
        │       └── closing_loc: (21,2)-(21,3) = "}"
        ├── @ CallNode (location: (23,0)-(23,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (23,0)-(23,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,1)-(23,9))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (23,3)-(23,7))
        │       │   ├── flags: ∅
        │       │   ├── parameters: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (23,5)-(23,6))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :a
        │       │   ├── opening_loc: (23,3)-(23,4) = "|"
        │       │   └── closing_loc: (23,6)-(23,7) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (23,1)-(23,2) = "{"
        │       └── closing_loc: (23,8)-(23,9) = "}"
        ├── @ CallNode (location: (25,0)-(25,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (25,0)-(25,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (25,1)-(25,12))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (25,3)-(25,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (25,4)-(25,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (25,4)-(25,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (25,7)-(25,9))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (25,8)-(25,9) = "b"
        │       │   │       └── operator_loc: (25,7)-(25,8) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (25,3)-(25,4) = "|"
        │       │   └── closing_loc: (25,9)-(25,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (25,1)-(25,2) = "{"
        │       └── closing_loc: (25,11)-(25,12) = "}"
        ├── @ CallNode (location: (27,0)-(27,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (27,0)-(27,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (27,1)-(27,15))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (27,3)-(27,13))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (27,4)-(27,12))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (27,4)-(27,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (27,7)-(27,8))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (27,7)-(27,8) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (27,10)-(27,12))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (27,11)-(27,12) = "b"
        │       │   │       └── operator_loc: (27,10)-(27,11) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (27,3)-(27,4) = "|"
        │       │   └── closing_loc: (27,12)-(27,13) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (27,1)-(27,2) = "{"
        │       └── closing_loc: (27,14)-(27,15) = "}"
        ├── @ CallNode (location: (29,0)-(29,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (29,0)-(29,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (29,1)-(29,19))
        │       ├── flags: ∅
        │       ├── locals: [:a, :r, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (29,3)-(29,17))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (29,4)-(29,16))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (29,4)-(29,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (29,7)-(29,9))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (29,8)-(29,9) = "r"
        │       │   │   │   └── operator_loc: (29,7)-(29,8) = "*"
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (29,11)-(29,12))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (29,14)-(29,16))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (29,15)-(29,16) = "b"
        │       │   │       └── operator_loc: (29,14)-(29,15) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (29,3)-(29,4) = "|"
        │       │   └── closing_loc: (29,16)-(29,17) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (29,1)-(29,2) = "{"
        │       └── closing_loc: (29,18)-(29,19) = "}"
        ├── @ CallNode (location: (31,0)-(31,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (31,0)-(31,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (31,1)-(31,16))
        │       ├── flags: ∅
        │       ├── locals: [:a, :s, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (31,3)-(31,14))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (31,4)-(31,13))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (31,4)-(31,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (31,7)-(31,9))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :s
        │       │   │   │   ├── name_loc: (31,8)-(31,9) = "s"
        │       │   │   │   └── operator_loc: (31,7)-(31,8) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (31,11)-(31,13))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (31,12)-(31,13) = "b"
        │       │   │       └── operator_loc: (31,11)-(31,12) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (31,3)-(31,4) = "|"
        │       │   └── closing_loc: (31,13)-(31,14) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (31,1)-(31,2) = "{"
        │       └── closing_loc: (31,15)-(31,16) = "}"
        ├── @ CallNode (location: (33,0)-(33,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (33,0)-(33,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (33,1)-(33,12))
        │       ├── flags: ∅
        │       ├── locals: [:a, :s]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (33,3)-(33,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (33,4)-(33,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (33,4)-(33,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (33,7)-(33,9))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :s
        │       │   │   │   ├── name_loc: (33,8)-(33,9) = "s"
        │       │   │   │   └── operator_loc: (33,7)-(33,8) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (33,3)-(33,4) = "|"
        │       │   └── closing_loc: (33,9)-(33,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (33,1)-(33,2) = "{"
        │       └── closing_loc: (33,11)-(33,12) = "}"
        ├── @ CallNode (location: (35,0)-(35,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (35,0)-(35,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (35,1)-(35,11))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (35,3)-(35,9))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (35,4)-(35,8))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (35,4)-(35,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (35,7)-(35,8))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (35,7)-(35,8) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (35,3)-(35,4) = "|"
        │       │   └── closing_loc: (35,8)-(35,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (35,1)-(35,2) = "{"
        │       └── closing_loc: (35,10)-(35,11) = "}"
        ├── @ CallNode (location: (37,0)-(37,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (37,0)-(37,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (37,1)-(37,12))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (37,3)-(37,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (37,4)-(37,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (37,4)-(37,5))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (37,7)-(37,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (37,8)-(37,9))
        │       │   │   │   └── flags: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (37,3)-(37,4) = "|"
        │       │   └── closing_loc: (37,9)-(37,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (37,1)-(37,2) = "{"
        │       └── closing_loc: (37,11)-(37,12) = "}"
        ├── @ CallNode (location: (39,0)-(39,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (39,0)-(39,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (39,1)-(39,11))
        │       ├── flags: ∅
        │       ├── locals: [:a, :c]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (39,3)-(39,9))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (39,4)-(39,8))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (39,4)-(39,5))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (39,7)-(39,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :c
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (39,3)-(39,4) = "|"
        │       │   └── closing_loc: (39,8)-(39,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (39,1)-(39,2) = "{"
        │       └── closing_loc: (39,10)-(39,11) = "}"
        ├── @ CallNode (location: (41,0)-(41,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (41,0)-(41,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (41,1)-(41,17))
        │       ├── flags: ∅
        │       ├── locals: [:a, :o, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (41,3)-(41,15))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (41,4)-(41,14))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (41,4)-(41,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (41,7)-(41,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (41,7)-(41,8) = "o"
        │       │   │   │       ├── operator_loc: (41,8)-(41,9) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (41,9)-(41,10))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (41,12)-(41,14))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (41,13)-(41,14) = "b"
        │       │   │       └── operator_loc: (41,12)-(41,13) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (41,3)-(41,4) = "|"
        │       │   └── closing_loc: (41,14)-(41,15) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (41,1)-(41,2) = "{"
        │       └── closing_loc: (41,16)-(41,17) = "}"
        ├── @ CallNode (location: (43,0)-(43,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (43,0)-(43,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (43,1)-(43,24))
        │       ├── flags: ∅
        │       ├── locals: [:a, :o, :r, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (43,3)-(43,22))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (43,4)-(43,21))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (43,4)-(43,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (43,7)-(43,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (43,7)-(43,8) = "o"
        │       │   │   │       ├── operator_loc: (43,8)-(43,9) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (43,9)-(43,10))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (43,12)-(43,14))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (43,13)-(43,14) = "r"
        │       │   │   │   └── operator_loc: (43,12)-(43,13) = "*"
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (43,16)-(43,17))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (43,19)-(43,21))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (43,20)-(43,21) = "b"
        │       │   │       └── operator_loc: (43,19)-(43,20) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (43,3)-(43,4) = "|"
        │       │   └── closing_loc: (43,21)-(43,22) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (43,1)-(43,2) = "{"
        │       └── closing_loc: (43,23)-(43,24) = "}"
        ├── @ CallNode (location: (45,0)-(45,27))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (45,0)-(45,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (45,1)-(45,27))
        │       ├── flags: ∅
        │       ├── locals: [:a, :o, :o1, :r, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (45,3)-(45,25))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (45,4)-(45,24))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (45,4)-(45,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 2)
        │       │   │   │   ├── @ OptionalParameterNode (location: (45,7)-(45,10))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   ├── name: :o
        │       │   │   │   │   ├── name_loc: (45,7)-(45,8) = "o"
        │       │   │   │   │   ├── operator_loc: (45,8)-(45,9) = "="
        │       │   │   │   │   └── value:
        │       │   │   │   │       @ IntegerNode (location: (45,9)-(45,10))
        │       │   │   │   │       ├── flags: static_literal, decimal
        │       │   │   │   │       └── value: 1
        │       │   │   │   └── @ OptionalParameterNode (location: (45,12)-(45,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o1
        │       │   │   │       ├── name_loc: (45,12)-(45,14) = "o1"
        │       │   │   │       ├── operator_loc: (45,14)-(45,15) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (45,15)-(45,16))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 2
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (45,18)-(45,20))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (45,19)-(45,20) = "r"
        │       │   │   │   └── operator_loc: (45,18)-(45,19) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (45,22)-(45,24))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (45,23)-(45,24) = "b"
        │       │   │       └── operator_loc: (45,22)-(45,23) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (45,3)-(45,4) = "|"
        │       │   └── closing_loc: (45,24)-(45,25) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (45,1)-(45,2) = "{"
        │       └── closing_loc: (45,26)-(45,27) = "}"
        ├── @ CallNode (location: (47,0)-(47,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (47,0)-(47,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (47,1)-(47,20))
        │       ├── flags: ∅
        │       ├── locals: [:a, :o, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (47,3)-(47,18))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (47,4)-(47,17))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (47,4)-(47,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (47,7)-(47,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (47,7)-(47,8) = "o"
        │       │   │   │       ├── operator_loc: (47,8)-(47,9) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (47,9)-(47,10))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (47,12)-(47,13))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (47,15)-(47,17))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (47,16)-(47,17) = "b"
        │       │   │       └── operator_loc: (47,15)-(47,16) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (47,3)-(47,4) = "|"
        │       │   └── closing_loc: (47,17)-(47,18) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (47,1)-(47,2) = "{"
        │       └── closing_loc: (47,19)-(47,20) = "}"
        ├── @ CallNode (location: (49,0)-(49,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (49,0)-(49,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (49,1)-(49,9))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (49,3)-(49,7))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (49,4)-(49,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (49,4)-(49,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (49,5)-(49,6))
        │       │   │   │   └── flags: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (49,3)-(49,4) = "|"
        │       │   └── closing_loc: (49,6)-(49,7) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (49,1)-(49,2) = "{"
        │       └── closing_loc: (49,8)-(49,9) = "}"
        ├── @ CallNode (location: (51,0)-(51,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (51,0)-(51,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (51,1)-(51,8))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (51,3)-(51,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (51,4)-(51,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (51,4)-(51,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (51,3)-(51,4) = "|"
        │       │   └── closing_loc: (51,5)-(51,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (51,1)-(51,2) = "{"
        │       └── closing_loc: (51,7)-(51,8) = "}"
        ├── @ CallNode (location: (53,0)-(53,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (53,0)-(53,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (53,1)-(53,8))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (53,3)-(53,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (53,4)-(53,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (53,4)-(53,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (53,3)-(53,4) = "|"
        │       │   └── closing_loc: (53,5)-(53,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (53,1)-(53,2) = "{"
        │       └── closing_loc: (53,7)-(53,8) = "}"
        ├── @ CallNode (location: (55,0)-(55,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (55,0)-(55,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (55,1)-(55,8))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (55,3)-(55,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (55,4)-(55,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (55,4)-(55,5))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (55,3)-(55,4) = "|"
        │       │   └── closing_loc: (55,5)-(55,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (55,1)-(55,2) = "{"
        │       └── closing_loc: (55,7)-(55,8) = "}"
        ├── @ CallNode (location: (57,0)-(57,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (57,0)-(57,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (57,1)-(57,17))
        │       ├── flags: ∅
        │       ├── locals: [:foo, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (57,3)-(57,15))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (57,4)-(57,14))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 1)
        │       │   │   │   └── @ OptionalKeywordParameterNode (location: (57,4)-(57,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :foo
        │       │   │   │       ├── name_loc: (57,4)-(57,8) = "foo:"
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (57,9)-(57,10))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (57,12)-(57,14))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (57,13)-(57,14) = "b"
        │       │   │       └── operator_loc: (57,12)-(57,13) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (57,3)-(57,4) = "|"
        │       │   └── closing_loc: (57,14)-(57,15) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (57,1)-(57,2) = "{"
        │       └── closing_loc: (57,16)-(57,17) = "}"
        ├── @ CallNode (location: (59,0)-(59,32))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (59,0)-(59,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (59,1)-(59,32))
        │       ├── flags: ∅
        │       ├── locals: [:foo, :bar, :baz, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (59,3)-(59,30))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (59,4)-(59,29))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 2)
        │       │   │   │   ├── @ OptionalKeywordParameterNode (location: (59,4)-(59,10))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   ├── name: :foo
        │       │   │   │   │   ├── name_loc: (59,4)-(59,8) = "foo:"
        │       │   │   │   │   └── value:
        │       │   │   │   │       @ IntegerNode (location: (59,9)-(59,10))
        │       │   │   │   │       ├── flags: static_literal, decimal
        │       │   │   │   │       └── value: 1
        │       │   │   │   └── @ OptionalKeywordParameterNode (location: (59,12)-(59,18))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :bar
        │       │   │   │       ├── name_loc: (59,12)-(59,16) = "bar:"
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (59,17)-(59,18))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 2
        │       │   │   ├── keyword_rest:
        │       │   │   │   @ KeywordRestParameterNode (location: (59,20)-(59,25))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :baz
        │       │   │   │   ├── name_loc: (59,22)-(59,25) = "baz"
        │       │   │   │   └── operator_loc: (59,20)-(59,22) = "**"
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (59,27)-(59,29))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (59,28)-(59,29) = "b"
        │       │   │       └── operator_loc: (59,27)-(59,28) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (59,3)-(59,4) = "|"
        │       │   └── closing_loc: (59,29)-(59,30) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (59,1)-(59,2) = "{"
        │       └── closing_loc: (59,31)-(59,32) = "}"
        ├── @ CallNode (location: (61,0)-(61,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (61,0)-(61,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (61,1)-(61,11))
        │       ├── flags: ∅
        │       ├── locals: [:foo]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (61,3)-(61,9))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (61,4)-(61,8))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 1)
        │       │   │   │   └── @ RequiredKeywordParameterNode (location: (61,4)-(61,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :foo
        │       │   │   │       └── name_loc: (61,4)-(61,8) = "foo:"
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (61,3)-(61,4) = "|"
        │       │   └── closing_loc: (61,8)-(61,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (61,1)-(61,2) = "{"
        │       └── closing_loc: (61,10)-(61,11) = "}"
        ├── @ CallNode (location: (63,0)-(63,14))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (63,0)-(63,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (63,1)-(63,14))
        │       ├── flags: ∅
        │       ├── locals: [:o, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (63,3)-(63,12))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (63,4)-(63,11))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (63,4)-(63,7))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (63,4)-(63,5) = "o"
        │       │   │   │       ├── operator_loc: (63,5)-(63,6) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (63,6)-(63,7))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (63,9)-(63,11))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (63,10)-(63,11) = "b"
        │       │   │       └── operator_loc: (63,9)-(63,10) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (63,3)-(63,4) = "|"
        │       │   └── closing_loc: (63,11)-(63,12) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (63,1)-(63,2) = "{"
        │       └── closing_loc: (63,13)-(63,14) = "}"
        ├── @ CallNode (location: (65,0)-(65,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (65,0)-(65,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (65,1)-(65,18))
        │       ├── flags: ∅
        │       ├── locals: [:o, :r, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (65,3)-(65,16))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (65,4)-(65,15))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (65,4)-(65,7))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (65,4)-(65,5) = "o"
        │       │   │   │       ├── operator_loc: (65,5)-(65,6) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (65,6)-(65,7))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (65,9)-(65,11))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (65,10)-(65,11) = "r"
        │       │   │   │   └── operator_loc: (65,9)-(65,10) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (65,13)-(65,15))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (65,14)-(65,15) = "b"
        │       │   │       └── operator_loc: (65,13)-(65,14) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (65,3)-(65,4) = "|"
        │       │   └── closing_loc: (65,15)-(65,16) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (65,1)-(65,2) = "{"
        │       └── closing_loc: (65,17)-(65,18) = "}"
        ├── @ CallNode (location: (67,0)-(67,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (67,0)-(67,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (67,1)-(67,21))
        │       ├── flags: ∅
        │       ├── locals: [:o, :r, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (67,3)-(67,19))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (67,4)-(67,18))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (67,4)-(67,7))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (67,4)-(67,5) = "o"
        │       │   │   │       ├── operator_loc: (67,5)-(67,6) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (67,6)-(67,7))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (67,9)-(67,11))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :r
        │       │   │   │   ├── name_loc: (67,10)-(67,11) = "r"
        │       │   │   │   └── operator_loc: (67,9)-(67,10) = "*"
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (67,13)-(67,14))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (67,16)-(67,18))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (67,17)-(67,18) = "b"
        │       │   │       └── operator_loc: (67,16)-(67,17) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (67,3)-(67,4) = "|"
        │       │   └── closing_loc: (67,18)-(67,19) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (67,1)-(67,2) = "{"
        │       └── closing_loc: (67,20)-(67,21) = "}"
        ├── @ CallNode (location: (69,0)-(69,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (69,0)-(69,1) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (69,1)-(69,17))
        │       ├── flags: ∅
        │       ├── locals: [:o, :p, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (69,3)-(69,15))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (69,4)-(69,14))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (69,4)-(69,7))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :o
        │       │   │   │       ├── name_loc: (69,4)-(69,5) = "o"
        │       │   │   │       ├── operator_loc: (69,5)-(69,6) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (69,6)-(69,7))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 1
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (69,9)-(69,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :p
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block:
        │       │   │       @ BlockParameterNode (location: (69,12)-(69,14))
        │       │   │       ├── flags: ∅
        │       │   │       ├── name: :b
        │       │   │       ├── name_loc: (69,13)-(69,14) = "b"
        │       │   │       └── operator_loc: (69,12)-(69,13) = "&"
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (69,3)-(69,4) = "|"
        │       │   └── closing_loc: (69,14)-(69,15) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (69,1)-(69,2) = "{"
        │       └── closing_loc: (69,16)-(69,17) = "}"
        └── @ CallNode (location: (71,0)-(71,7))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (71,0)-(71,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (71,1)-(71,7))
                ├── flags: ∅
                ├── locals: []
                ├── parameters:
                │   @ BlockParametersNode (location: (71,3)-(71,5))
                │   ├── flags: ∅
                │   ├── parameters: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (71,3)-(71,4) = "|"
                │   └── closing_loc: (71,4)-(71,5) = "|"
                ├── body: ∅
                ├── opening_loc: (71,1)-(71,2) = "{"
                └── closing_loc: (71,6)-(71,7) = "}"
