@ ProgramNode (location: (1,0)-(33,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(33,21))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ CallNode (location: (1,0)-(1,13))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (1,0)-(1,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,13))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,6)-(1,11))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (1,6)-(1,11))
        │       │           ├── flags: newline
        │       │           ├── arguments: ∅
        │       │           └── keyword_loc: (1,6)-(1,11) = "break"
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (1,12)-(1,13) = "}"
        ├── @ CallNode (location: (3,0)-(3,27))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (3,0)-(3,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(3,27))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (3,6)-(3,25))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (3,6)-(3,25))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (3,12)-(3,25))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ ParenthesesNode (location: (3,12)-(3,15))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,13)-(3,14))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,13)-(3,14))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 1
        │       │           │       │   ├── opening_loc: (3,12)-(3,13) = "("
        │       │           │       │   └── closing_loc: (3,14)-(3,15) = ")"
        │       │           │       ├── @ ParenthesesNode (location: (3,17)-(3,20))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,18)-(3,19))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,18)-(3,19))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 2
        │       │           │       │   ├── opening_loc: (3,17)-(3,18) = "("
        │       │           │       │   └── closing_loc: (3,19)-(3,20) = ")"
        │       │           │       └── @ ParenthesesNode (location: (3,22)-(3,25))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (3,23)-(3,24))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (3,23)-(3,24))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 3
        │       │           │           ├── opening_loc: (3,22)-(3,23) = "("
        │       │           │           └── closing_loc: (3,24)-(3,25) = ")"
        │       │           └── keyword_loc: (3,6)-(3,11) = "break"
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (3,26)-(3,27) = "}"
        ├── @ CallNode (location: (5,0)-(5,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (5,0)-(5,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(5,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (5,6)-(5,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (5,6)-(5,13))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (5,12)-(5,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ IntegerNode (location: (5,12)-(5,13))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 1
        │       │           └── keyword_loc: (5,6)-(5,11) = "break"
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (5,14)-(5,15) = "}"
        ├── @ CallNode (location: (7,0)-(8,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (7,0)-(7,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(8,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (7,6)-(8,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (7,6)-(8,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (7,12)-(8,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (7,12)-(7,13))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (7,15)-(7,16))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (8,0)-(8,1))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (7,6)-(7,11) = "break"
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (8,2)-(8,3) = "}"
        ├── @ CallNode (location: (10,0)-(10,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (10,0)-(10,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (10,4)-(10,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (10,6)-(10,19))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (10,6)-(10,19))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (10,12)-(10,19))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (10,12)-(10,13))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (10,15)-(10,16))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (10,18)-(10,19))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (10,6)-(10,11) = "break"
        │       ├── opening_loc: (10,4)-(10,5) = "{"
        │       └── closing_loc: (10,20)-(10,21) = "}"
        ├── @ CallNode (location: (12,0)-(12,23))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (12,0)-(12,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (12,4)-(12,23))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (12,6)-(12,21))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (12,6)-(12,21))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (12,12)-(12,21))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ArrayNode (location: (12,12)-(12,21))
        │       │           │           ├── flags: static_literal
        │       │           │           ├── elements: (length: 3)
        │       │           │           │   ├── @ IntegerNode (location: (12,13)-(12,14))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 1
        │       │           │           │   ├── @ IntegerNode (location: (12,16)-(12,17))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 2
        │       │           │           │   └── @ IntegerNode (location: (12,19)-(12,20))
        │       │           │           │       ├── flags: static_literal, decimal
        │       │           │           │       └── value: 3
        │       │           │           ├── opening_loc: (12,12)-(12,13) = "["
        │       │           │           └── closing_loc: (12,20)-(12,21) = "]"
        │       │           └── keyword_loc: (12,6)-(12,11) = "break"
        │       ├── opening_loc: (12,4)-(12,5) = "{"
        │       └── closing_loc: (12,22)-(12,23) = "}"
        ├── @ CallNode (location: (14,0)-(17,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (14,0)-(14,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (14,4)-(17,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (14,6)-(17,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (14,6)-(17,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (14,11)-(17,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (14,11)-(17,1))
        │       │           │           ├── flags: multiple_statements
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (15,2)-(16,3))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 2)
        │       │           │           │       ├── @ IntegerNode (location: (15,2)-(15,3))
        │       │           │           │       │   ├── flags: newline, static_literal, decimal
        │       │           │           │       │   └── value: 1
        │       │           │           │       └── @ IntegerNode (location: (16,2)-(16,3))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 2
        │       │           │           ├── opening_loc: (14,11)-(14,12) = "("
        │       │           │           └── closing_loc: (17,0)-(17,1) = ")"
        │       │           └── keyword_loc: (14,6)-(14,11) = "break"
        │       ├── opening_loc: (14,4)-(14,5) = "{"
        │       └── closing_loc: (17,2)-(17,3) = "}"
        ├── @ CallNode (location: (19,0)-(19,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (19,0)-(19,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,4)-(19,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (19,6)-(19,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (19,6)-(19,13))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (19,11)-(19,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (19,11)-(19,13))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body: ∅
        │       │           │           ├── opening_loc: (19,11)-(19,12) = "("
        │       │           │           └── closing_loc: (19,12)-(19,13) = ")"
        │       │           └── keyword_loc: (19,6)-(19,11) = "break"
        │       ├── opening_loc: (19,4)-(19,5) = "{"
        │       └── closing_loc: (19,14)-(19,15) = "}"
        ├── @ CallNode (location: (21,0)-(21,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (21,0)-(21,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (21,4)-(21,16))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (21,6)-(21,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (21,6)-(21,14))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (21,11)-(21,14))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (21,11)-(21,14))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (21,12)-(21,13))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (21,12)-(21,13))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           ├── opening_loc: (21,11)-(21,12) = "("
        │       │           │           └── closing_loc: (21,13)-(21,14) = ")"
        │       │           └── keyword_loc: (21,6)-(21,11) = "break"
        │       ├── opening_loc: (21,4)-(21,5) = "{"
        │       └── closing_loc: (21,15)-(21,16) = "}"
        ├── @ CallNode (location: (23,0)-(23,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (23,0)-(23,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,4)-(23,17))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (23,6)-(23,15))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ ParenthesesNode (location: (23,6)-(23,15))
        │       │           ├── flags: newline
        │       │           ├── body:
        │       │           │   @ StatementsNode (location: (23,7)-(23,14))
        │       │           │   ├── flags: ∅
        │       │           │   └── body: (length: 1)
        │       │           │       └── @ BreakNode (location: (23,7)-(23,14))
        │       │           │           ├── flags: newline
        │       │           │           ├── arguments:
        │       │           │           │   @ ArgumentsNode (location: (23,13)-(23,14))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── arguments: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (23,13)-(23,14))
        │       │           │           │           ├── flags: static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           └── keyword_loc: (23,7)-(23,12) = "break"
        │       │           ├── opening_loc: (23,6)-(23,7) = "("
        │       │           └── closing_loc: (23,14)-(23,15) = ")"
        │       ├── opening_loc: (23,4)-(23,5) = "{"
        │       └── closing_loc: (23,16)-(23,17) = "}"
        ├── @ CallNode (location: (25,0)-(25,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (25,0)-(25,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (25,4)-(25,24))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (25,6)-(25,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ AndNode (location: (25,6)-(25,22))
        │       │           ├── flags: newline
        │       │           ├── left:
        │       │           │   @ CallNode (location: (25,6)-(25,9))
        │       │           │   ├── flags: variable_call, ignore_visibility
        │       │           │   ├── receiver: ∅
        │       │           │   ├── call_operator_loc: ∅
        │       │           │   ├── name: :foo
        │       │           │   ├── message_loc: (25,6)-(25,9) = "foo"
        │       │           │   ├── opening_loc: ∅
        │       │           │   ├── arguments: ∅
        │       │           │   ├── closing_loc: ∅
        │       │           │   └── block: ∅
        │       │           ├── right:
        │       │           │   @ ParenthesesNode (location: (25,13)-(25,22))
        │       │           │   ├── flags: ∅
        │       │           │   ├── body:
        │       │           │   │   @ StatementsNode (location: (25,14)-(25,21))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   └── body: (length: 1)
        │       │           │   │       └── @ BreakNode (location: (25,14)-(25,21))
        │       │           │   │           ├── flags: newline
        │       │           │   │           ├── arguments:
        │       │           │   │           │   @ ArgumentsNode (location: (25,20)-(25,21))
        │       │           │   │           │   ├── flags: ∅
        │       │           │   │           │   └── arguments: (length: 1)
        │       │           │   │           │       └── @ IntegerNode (location: (25,20)-(25,21))
        │       │           │   │           │           ├── flags: static_literal, decimal
        │       │           │   │           │           └── value: 1
        │       │           │   │           └── keyword_loc: (25,14)-(25,19) = "break"
        │       │           │   ├── opening_loc: (25,13)-(25,14) = "("
        │       │           │   └── closing_loc: (25,21)-(25,22) = ")"
        │       │           └── operator_loc: (25,10)-(25,12) = "&&"
        │       ├── opening_loc: (25,4)-(25,5) = "{"
        │       └── closing_loc: (25,23)-(25,24) = "}"
        ├── @ CallNode (location: (27,0)-(27,22))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (27,0)-(27,16))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (27,0)-(27,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (27,4)-(27,16))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body:
        │   │       │   @ StatementsNode (location: (27,6)-(27,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ BreakNode (location: (27,6)-(27,14))
        │   │       │           ├── flags: newline
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (27,12)-(27,14))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ IntegerNode (location: (27,12)-(27,14))
        │   │       │           │           ├── flags: static_literal, decimal
        │   │       │           │           └── value: 42
        │   │       │           └── keyword_loc: (27,6)-(27,11) = "break"
        │   │       ├── opening_loc: (27,4)-(27,5) = "{"
        │   │       └── closing_loc: (27,15)-(27,16) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (27,17)-(27,19) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,20)-(27,22))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,20)-(27,22))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,23))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (29,4)-(29,17))
        │   │       ├── flags: ∅
        │   │       ├── locals: [:a]
        │   │       ├── parameters:
        │   │       │   @ BlockParametersNode (location: (29,6)-(29,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── parameters:
        │   │       │   │   @ ParametersNode (location: (29,7)-(29,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── requireds: (length: 1)
        │   │       │   │   │   └── @ RequiredParameterNode (location: (29,7)-(29,8))
        │   │       │   │   │       ├── flags: ∅
        │   │       │   │   │       └── name: :a
        │   │       │   │   ├── optionals: (length: 0)
        │   │       │   │   ├── rest: ∅
        │   │       │   │   ├── posts: (length: 0)
        │   │       │   │   ├── keywords: (length: 0)
        │   │       │   │   ├── keyword_rest: ∅
        │   │       │   │   └── block: ∅
        │   │       │   ├── locals: (length: 0)
        │   │       │   ├── opening_loc: (29,6)-(29,7) = "|"
        │   │       │   └── closing_loc: (29,8)-(29,9) = "|"
        │   │       ├── body:
        │   │       │   @ StatementsNode (location: (29,10)-(29,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ BreakNode (location: (29,10)-(29,15))
        │   │       │           ├── flags: newline
        │   │       │           ├── arguments: ∅
        │   │       │           └── keyword_loc: (29,10)-(29,15) = "break"
        │   │       ├── opening_loc: (29,4)-(29,5) = "{"
        │   │       └── closing_loc: (29,16)-(29,17) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (29,18)-(29,20) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,21)-(29,23))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,21)-(29,23))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ WhileNode (location: (31,0)-(31,21))
        │   ├── flags: newline
        │   ├── keyword_loc: (31,0)-(31,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (31,18)-(31,21) = "end"
        │   ├── predicate:
        │   │   @ AndNode (location: (31,6)-(31,16))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ CallNode (location: (31,6)-(31,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :_
        │   │   │   ├── message_loc: (31,6)-(31,7) = "_"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ BreakNode (location: (31,11)-(31,16))
        │   │   │   ├── flags: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   └── keyword_loc: (31,11)-(31,16) = "break"
        │   │   └── operator_loc: (31,8)-(31,10) = "&&"
        │   └── statements: ∅
        └── @ UntilNode (location: (33,0)-(33,21))
            ├── flags: newline
            ├── keyword_loc: (33,0)-(33,5) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (33,18)-(33,21) = "end"
            ├── predicate:
            │   @ AndNode (location: (33,6)-(33,16))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ CallNode (location: (33,6)-(33,7))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :_
            │   │   ├── message_loc: (33,6)-(33,7) = "_"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── right:
            │   │   @ BreakNode (location: (33,11)-(33,16))
            │   │   ├── flags: ∅
            │   │   ├── arguments: ∅
            │   │   └── keyword_loc: (33,11)-(33,16) = "break"
            │   └── operator_loc: (33,8)-(33,10) = "&&"
            └── statements: ∅
