@ ProgramNode (location: (1,0)-(9,52))
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(9,52))
    └── body: (length: 5)
        ├── @ CallNode (location: (1,0)-(1,42))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (1,0)-(1,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,42))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (1,2)-(1,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (1,2)-(1,3) = ":"
        │   │       │   ├── value_loc: (1,3)-(1,6) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       └── @ HashNode (location: (1,8)-(1,42))
        │   │           ├── opening_loc: (1,8)-(1,9) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocNode (location: (1,9)-(1,25))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (1,9)-(1,13))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: (1,9)-(1,10) = "\""
        │   │           │   │   │   ├── value_loc: (1,10)-(1,11) = "a"
        │   │           │   │   │   ├── closing_loc: (1,11)-(1,13) = "\":"
        │   │           │   │   │   └── unescaped: "a"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ CallNode (location: (1,14)-(1,25))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── receiver: ∅
        │   │           │   │   │   ├── call_operator_loc: ∅
        │   │           │   │   │   ├── name: :proc
        │   │           │   │   │   ├── message_loc: (1,14)-(1,18) = "proc"
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── arguments: ∅
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── block:
        │   │           │   │   │       @ BlockNode (location: (1,19)-(1,25))
        │   │           │   │   │       ├── locals: []
        │   │           │   │   │       ├── locals_body_index: 0
        │   │           │   │   │       ├── parameters: ∅
        │   │           │   │   │       ├── body: ∅
        │   │           │   │   │       ├── opening_loc: (1,19)-(1,21) = "do"
        │   │           │   │   │       └── closing_loc: (1,22)-(1,25) = "end"
        │   │           │   │   └── operator_loc: ∅
        │   │           │   └── @ AssocNode (location: (1,27)-(1,41))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (1,27)-(1,29))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (1,27)-(1,28) = "b"
        │   │           │       │   ├── closing_loc: (1,28)-(1,29) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ CallNode (location: (1,30)-(1,41))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :proc
        │   │           │       │   ├── message_loc: (1,30)-(1,34) = "proc"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block:
        │   │           │       │       @ BlockNode (location: (1,35)-(1,41))
        │   │           │       │       ├── locals: []
        │   │           │       │       ├── locals_body_index: 0
        │   │           │       │       ├── parameters: ∅
        │   │           │       │       ├── body: ∅
        │   │           │       │       ├── opening_loc: (1,35)-(1,37) = "do"
        │   │           │       │       └── closing_loc: (1,38)-(1,41) = "end"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (1,41)-(1,42) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,40))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (3,0)-(3,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,2)-(3,40))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (3,2)-(3,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (3,2)-(3,3) = ":"
        │   │       │   ├── value_loc: (3,3)-(3,6) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       └── @ HashNode (location: (3,8)-(3,40))
        │   │           ├── opening_loc: (3,8)-(3,9) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocSplatNode (location: (3,9)-(3,23))
        │   │           │   │   ├── value:
        │   │           │   │   │   @ CallNode (location: (3,12)-(3,23))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── receiver: ∅
        │   │           │   │   │   ├── call_operator_loc: ∅
        │   │           │   │   │   ├── name: :proc
        │   │           │   │   │   ├── message_loc: (3,12)-(3,16) = "proc"
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── arguments: ∅
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── block:
        │   │           │   │   │       @ BlockNode (location: (3,17)-(3,23))
        │   │           │   │   │       ├── locals: []
        │   │           │   │   │       ├── locals_body_index: 0
        │   │           │   │   │       ├── parameters: ∅
        │   │           │   │   │       ├── body: ∅
        │   │           │   │   │       ├── opening_loc: (3,17)-(3,19) = "do"
        │   │           │   │   │       └── closing_loc: (3,20)-(3,23) = "end"
        │   │           │   │   └── operator_loc: (3,9)-(3,11) = "**"
        │   │           │   └── @ AssocNode (location: (3,25)-(3,39))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (3,25)-(3,27))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (3,25)-(3,26) = "b"
        │   │           │       │   ├── closing_loc: (3,26)-(3,27) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ CallNode (location: (3,28)-(3,39))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :proc
        │   │           │       │   ├── message_loc: (3,28)-(3,32) = "proc"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block:
        │   │           │       │       @ BlockNode (location: (3,33)-(3,39))
        │   │           │       │       ├── locals: []
        │   │           │       │       ├── locals_body_index: 0
        │   │           │       │       ├── parameters: ∅
        │   │           │       │       ├── body: ∅
        │   │           │       │       ├── opening_loc: (3,33)-(3,35) = "do"
        │   │           │       │       └── closing_loc: (3,36)-(3,39) = "end"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (3,39)-(3,40) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,43))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (5,0)-(5,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,2)-(5,43))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (5,2)-(5,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (5,2)-(5,3) = ":"
        │   │       │   ├── value_loc: (5,3)-(5,6) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       └── @ HashNode (location: (5,8)-(5,43))
        │   │           ├── opening_loc: (5,8)-(5,9) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocNode (location: (5,9)-(5,26))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (5,9)-(5,11))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: (5,9)-(5,10) = ":"
        │   │           │   │   │   ├── value_loc: (5,10)-(5,11) = "a"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "a"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ CallNode (location: (5,15)-(5,26))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── receiver: ∅
        │   │           │   │   │   ├── call_operator_loc: ∅
        │   │           │   │   │   ├── name: :proc
        │   │           │   │   │   ├── message_loc: (5,15)-(5,19) = "proc"
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── arguments: ∅
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── block:
        │   │           │   │   │       @ BlockNode (location: (5,20)-(5,26))
        │   │           │   │   │       ├── locals: []
        │   │           │   │   │       ├── locals_body_index: 0
        │   │           │   │   │       ├── parameters: ∅
        │   │           │   │   │       ├── body: ∅
        │   │           │   │   │       ├── opening_loc: (5,20)-(5,22) = "do"
        │   │           │   │   │       └── closing_loc: (5,23)-(5,26) = "end"
        │   │           │   │   └── operator_loc: (5,12)-(5,14) = "=>"
        │   │           │   └── @ AssocNode (location: (5,28)-(5,42))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (5,28)-(5,30))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (5,28)-(5,29) = "b"
        │   │           │       │   ├── closing_loc: (5,29)-(5,30) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ CallNode (location: (5,31)-(5,42))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :proc
        │   │           │       │   ├── message_loc: (5,31)-(5,35) = "proc"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block:
        │   │           │       │       @ BlockNode (location: (5,36)-(5,42))
        │   │           │       │       ├── locals: []
        │   │           │       │       ├── locals_body_index: 0
        │   │           │       │       ├── parameters: ∅
        │   │           │       │       ├── body: ∅
        │   │           │       │       ├── opening_loc: (5,36)-(5,38) = "do"
        │   │           │       │       └── closing_loc: (5,39)-(5,42) = "end"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (5,42)-(5,43) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(7,40))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (7,0)-(7,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,2)-(7,40))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (7,2)-(7,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (7,2)-(7,3) = ":"
        │   │       │   ├── value_loc: (7,3)-(7,6) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       └── @ HashNode (location: (7,8)-(7,40))
        │   │           ├── opening_loc: (7,8)-(7,9) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocNode (location: (7,9)-(7,23))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (7,9)-(7,11))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── value_loc: (7,9)-(7,10) = "a"
        │   │           │   │   │   ├── closing_loc: (7,10)-(7,11) = ":"
        │   │           │   │   │   └── unescaped: "a"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ CallNode (location: (7,12)-(7,23))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── receiver: ∅
        │   │           │   │   │   ├── call_operator_loc: ∅
        │   │           │   │   │   ├── name: :proc
        │   │           │   │   │   ├── message_loc: (7,12)-(7,16) = "proc"
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── arguments: ∅
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── block:
        │   │           │   │   │       @ BlockNode (location: (7,17)-(7,23))
        │   │           │   │   │       ├── locals: []
        │   │           │   │   │       ├── locals_body_index: 0
        │   │           │   │   │       ├── parameters: ∅
        │   │           │   │   │       ├── body: ∅
        │   │           │   │   │       ├── opening_loc: (7,17)-(7,19) = "do"
        │   │           │   │   │       └── closing_loc: (7,20)-(7,23) = "end"
        │   │           │   │   └── operator_loc: ∅
        │   │           │   └── @ AssocNode (location: (7,25)-(7,39))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (7,25)-(7,27))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (7,25)-(7,26) = "b"
        │   │           │       │   ├── closing_loc: (7,26)-(7,27) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ CallNode (location: (7,28)-(7,39))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :proc
        │   │           │       │   ├── message_loc: (7,28)-(7,32) = "proc"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block:
        │   │           │       │       @ BlockNode (location: (7,33)-(7,39))
        │   │           │       │       ├── locals: []
        │   │           │       │       ├── locals_body_index: 0
        │   │           │       │       ├── parameters: ∅
        │   │           │       │       ├── body: ∅
        │   │           │       │       ├── opening_loc: (7,33)-(7,35) = "do"
        │   │           │       │       └── closing_loc: (7,36)-(7,39) = "end"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (7,39)-(7,40) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (9,0)-(9,52))
            ├── flags: ∅
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (9,0)-(9,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (9,2)-(9,52))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ SymbolNode (location: (9,2)-(9,6))
            │       │   ├── flags: ∅
            │       │   ├── opening_loc: (9,2)-(9,3) = ":"
            │       │   ├── value_loc: (9,3)-(9,6) = "foo"
            │       │   ├── closing_loc: ∅
            │       │   └── unescaped: "foo"
            │       └── @ HashNode (location: (9,8)-(9,52))
            │           ├── opening_loc: (9,8)-(9,9) = "{"
            │           ├── elements: (length: 2)
            │           │   ├── @ AssocNode (location: (9,9)-(9,35))
            │           │   │   ├── key:
            │           │   │   │   @ CallNode (location: (9,9)-(9,20))
            │           │   │   │   ├── flags: ∅
            │           │   │   │   ├── receiver: ∅
            │           │   │   │   ├── call_operator_loc: ∅
            │           │   │   │   ├── name: :proc
            │           │   │   │   ├── message_loc: (9,9)-(9,13) = "proc"
            │           │   │   │   ├── opening_loc: ∅
            │           │   │   │   ├── arguments: ∅
            │           │   │   │   ├── closing_loc: ∅
            │           │   │   │   └── block:
            │           │   │   │       @ BlockNode (location: (9,14)-(9,20))
            │           │   │   │       ├── locals: []
            │           │   │   │       ├── locals_body_index: 0
            │           │   │   │       ├── parameters: ∅
            │           │   │   │       ├── body: ∅
            │           │   │   │       ├── opening_loc: (9,14)-(9,16) = "do"
            │           │   │   │       └── closing_loc: (9,17)-(9,20) = "end"
            │           │   │   ├── value:
            │           │   │   │   @ CallNode (location: (9,24)-(9,35))
            │           │   │   │   ├── flags: ∅
            │           │   │   │   ├── receiver: ∅
            │           │   │   │   ├── call_operator_loc: ∅
            │           │   │   │   ├── name: :proc
            │           │   │   │   ├── message_loc: (9,24)-(9,28) = "proc"
            │           │   │   │   ├── opening_loc: ∅
            │           │   │   │   ├── arguments: ∅
            │           │   │   │   ├── closing_loc: ∅
            │           │   │   │   └── block:
            │           │   │   │       @ BlockNode (location: (9,29)-(9,35))
            │           │   │   │       ├── locals: []
            │           │   │   │       ├── locals_body_index: 0
            │           │   │   │       ├── parameters: ∅
            │           │   │   │       ├── body: ∅
            │           │   │   │       ├── opening_loc: (9,29)-(9,31) = "do"
            │           │   │   │       └── closing_loc: (9,32)-(9,35) = "end"
            │           │   │   └── operator_loc: (9,21)-(9,23) = "=>"
            │           │   └── @ AssocNode (location: (9,37)-(9,51))
            │           │       ├── key:
            │           │       │   @ SymbolNode (location: (9,37)-(9,39))
            │           │       │   ├── flags: ∅
            │           │       │   ├── opening_loc: ∅
            │           │       │   ├── value_loc: (9,37)-(9,38) = "b"
            │           │       │   ├── closing_loc: (9,38)-(9,39) = ":"
            │           │       │   └── unescaped: "b"
            │           │       ├── value:
            │           │       │   @ CallNode (location: (9,40)-(9,51))
            │           │       │   ├── flags: ∅
            │           │       │   ├── receiver: ∅
            │           │       │   ├── call_operator_loc: ∅
            │           │       │   ├── name: :proc
            │           │       │   ├── message_loc: (9,40)-(9,44) = "proc"
            │           │       │   ├── opening_loc: ∅
            │           │       │   ├── arguments: ∅
            │           │       │   ├── closing_loc: ∅
            │           │       │   └── block:
            │           │       │       @ BlockNode (location: (9,45)-(9,51))
            │           │       │       ├── locals: []
            │           │       │       ├── locals_body_index: 0
            │           │       │       ├── parameters: ∅
            │           │       │       ├── body: ∅
            │           │       │       ├── opening_loc: (9,45)-(9,47) = "do"
            │           │       │       └── closing_loc: (9,48)-(9,51) = "end"
            │           │       └── operator_loc: ∅
            │           └── closing_loc: (9,51)-(9,52) = "}"
            ├── closing_loc: ∅
            └── block: ∅
