@ ProgramNode (location: (1,0)-(15,3))
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(15,3))
    └── body: (length: 11)
        ├── @ NextNode (location: (1,0)-(1,4))
        │   ├── arguments: ∅
        │   └── keyword_loc: (1,0)-(1,4) = "next"
        ├── @ ReturnNode (location: (2,0)-(2,6))
        │   ├── keyword_loc: (2,0)-(2,6) = "return"
        │   └── arguments: ∅
        ├── @ BreakNode (location: (3,0)-(3,5))
        │   ├── arguments: ∅
        │   └── keyword_loc: (3,0)-(3,5) = "break"
        ├── @ RetryNode (location: (4,0)-(4,5))
        ├── @ RedoNode (location: (5,0)-(5,4))
        ├── @ ReturnNode (location: (6,0)-(6,8))
        │   ├── keyword_loc: (6,0)-(6,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (6,7)-(6,8))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ IntegerNode (location: (6,7)-(6,8))
        │               └── flags: decimal
        ├── @ ReturnNode (location: (7,0)-(7,11))
        │   ├── keyword_loc: (7,0)-(7,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (7,7)-(7,11))
        │       ├── flags: ∅
        │       └── arguments: (length: 2)
        │           ├── @ IntegerNode (location: (7,7)-(7,8))
        │           │   └── flags: decimal
        │           └── @ IntegerNode (location: (7,10)-(7,11))
        │               └── flags: decimal
        ├── @ ReturnNode (location: (8,0)-(8,19))
        │   ├── keyword_loc: (8,0)-(8,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (8,7)-(8,19))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ IfNode (location: (8,7)-(8,19))
        │               ├── if_keyword_loc: ∅
        │               ├── predicate:
        │               │   @ TrueNode (location: (8,7)-(8,11))
        │               ├── then_keyword_loc: (8,12)-(8,13) = "?"
        │               ├── statements:
        │               │   @ StatementsNode (location: (8,14)-(8,15))
        │               │   └── body: (length: 1)
        │               │       └── @ IntegerNode (location: (8,14)-(8,15))
        │               │           └── flags: decimal
        │               ├── consequent:
        │               │   @ ElseNode (location: (8,16)-(8,19))
        │               │   ├── else_keyword_loc: (8,16)-(8,17) = ":"
        │               │   ├── statements:
        │               │   │   @ StatementsNode (location: (8,18)-(8,19))
        │               │   │   └── body: (length: 1)
        │               │   │       └── @ IntegerNode (location: (8,18)-(8,19))
        │               │   │           └── flags: decimal
        │               │   └── end_keyword_loc: ∅
        │               └── end_keyword_loc: ∅
        ├── @ BreakNode (location: (9,0)-(9,18))
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,6)-(9,18))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IfNode (location: (9,6)-(9,18))
        │   │           ├── if_keyword_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ TrueNode (location: (9,6)-(9,10))
        │   │           ├── then_keyword_loc: (9,11)-(9,12) = "?"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (9,13)-(9,14))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (9,13)-(9,14))
        │   │           │           └── flags: decimal
        │   │           ├── consequent:
        │   │           │   @ ElseNode (location: (9,15)-(9,18))
        │   │           │   ├── else_keyword_loc: (9,15)-(9,16) = ":"
        │   │           │   ├── statements:
        │   │           │   │   @ StatementsNode (location: (9,17)-(9,18))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (9,17)-(9,18))
        │   │           │   │           └── flags: decimal
        │   │           │   └── end_keyword_loc: ∅
        │   │           └── end_keyword_loc: ∅
        │   └── keyword_loc: (9,0)-(9,5) = "break"
        ├── @ NextNode (location: (10,0)-(10,17))
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (10,5)-(10,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IfNode (location: (10,5)-(10,17))
        │   │           ├── if_keyword_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ TrueNode (location: (10,5)-(10,9))
        │   │           ├── then_keyword_loc: (10,10)-(10,11) = "?"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (10,12)-(10,13))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (10,12)-(10,13))
        │   │           │           └── flags: decimal
        │   │           ├── consequent:
        │   │           │   @ ElseNode (location: (10,14)-(10,17))
        │   │           │   ├── else_keyword_loc: (10,14)-(10,15) = ":"
        │   │           │   ├── statements:
        │   │           │   │   @ StatementsNode (location: (10,16)-(10,17))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (10,16)-(10,17))
        │   │           │   │           └── flags: decimal
        │   │           │   └── end_keyword_loc: ∅
        │   │           └── end_keyword_loc: ∅
        │   └── keyword_loc: (10,0)-(10,4) = "next"
        └── @ ReturnNode (location: (11,0)-(15,3))
            ├── keyword_loc: (11,0)-(11,6) = "return"
            └── arguments:
                @ ArgumentsNode (location: (11,7)-(15,3))
                ├── flags: ∅
                └── arguments: (length: 2)
                    ├── @ TrueNode (location: (11,7)-(11,11))
                    └── @ IfNode (location: (11,13)-(15,3))
                        ├── if_keyword_loc: (11,13)-(11,15) = "if"
                        ├── predicate:
                        │   @ TrueNode (location: (11,16)-(11,20))
                        ├── then_keyword_loc: ∅
                        ├── statements:
                        │   @ StatementsNode (location: (12,2)-(12,3))
                        │   └── body: (length: 1)
                        │       └── @ IntegerNode (location: (12,2)-(12,3))
                        │           └── flags: decimal
                        ├── consequent:
                        │   @ ElseNode (location: (13,0)-(15,3))
                        │   ├── else_keyword_loc: (13,0)-(13,4) = "else"
                        │   ├── statements:
                        │   │   @ StatementsNode (location: (14,2)-(14,3))
                        │   │   └── body: (length: 1)
                        │   │       └── @ IntegerNode (location: (14,2)-(14,3))
                        │   │           └── flags: decimal
                        │   └── end_keyword_loc: (15,0)-(15,3) = "end"
                        └── end_keyword_loc: (15,0)-(15,3) = "end"
