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