@ ProgramNode (location: (0...690))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...690))
    └── body: (length: 31)
        ├── @ DefNode (location: (0...13))
        │   ├── name: :f
        │   ├── name_loc: (4...5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (6...8))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (6...8))
        │   │       ├── name: :b
        │   │       ├── name_loc: (7...8) = "b"
        │   │       └── operator_loc: (6...7) = "&"
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (0...3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (10...13) = "end"
        ├── @ DefNode (location: (15...33))
        │   ├── name: :f
        │   ├── name_loc: (19...20) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (22...27))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (22...27))
        │   │   │       ├── parameters: (length: 1)
        │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (23...26))
        │   │   │       │       ├── parameters: (length: 1)
        │   │   │       │       │   └── @ RequiredParameterNode (location: (24...25))
        │   │   │       │       │       └── name: :a
        │   │   │       │       ├── opening_loc: (23...24) = "("
        │   │   │       │       └── closing_loc: (25...26) = ")"
        │   │   │       ├── opening_loc: (22...23) = "("
        │   │   │       └── closing_loc: (26...27) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (15...18) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (21...22) = "("
        │   ├── rparen_loc: (27...28) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (30...33) = "end"
        ├── @ DefNode (location: (35...51))
        │   ├── name: :f
        │   ├── name_loc: (39...40) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (42...45))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (42...45))
        │   │   │       ├── parameters: (length: 1)
        │   │   │       │   └── @ SplatNode (location: (43...44))
        │   │   │       │       ├── operator_loc: (43...44) = "*"
        │   │   │       │       └── expression: ∅
        │   │   │       ├── opening_loc: (42...43) = "("
        │   │   │       └── closing_loc: (44...45) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (35...38) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (41...42) = "("
        │   ├── rparen_loc: (45...46) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (48...51) = "end"
        ├── @ DefNode (location: (53...72))
        │   ├── name: :f
        │   ├── name_loc: (57...58) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (60...66))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (60...66))
        │   │   │       ├── parameters: (length: 2)
        │   │   │       │   ├── @ SplatNode (location: (61...62))
        │   │   │       │   │   ├── operator_loc: (61...62) = "*"
        │   │   │       │   │   └── expression: ∅
        │   │   │       │   └── @ RequiredParameterNode (location: (64...65))
        │   │   │       │       └── name: :p
        │   │   │       ├── opening_loc: (60...61) = "("
        │   │   │       └── closing_loc: (65...66) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:p]
        │   ├── def_keyword_loc: (53...56) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (59...60) = "("
        │   ├── rparen_loc: (66...67) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (69...72) = "end"
        ├── @ DefNode (location: (74...91))
        │   ├── name: :f
        │   ├── name_loc: (78...79) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (81...85))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (81...85))
        │   │   │       ├── parameters: (length: 1)
        │   │   │       │   └── @ SplatNode (location: (82...84))
        │   │   │       │       ├── operator_loc: (82...83) = "*"
        │   │   │       │       └── expression:
        │   │   │       │           @ RequiredParameterNode (location: (83...84))
        │   │   │       │           └── name: :r
        │   │   │       ├── opening_loc: (81...82) = "("
        │   │   │       └── closing_loc: (84...85) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:r]
        │   ├── def_keyword_loc: (74...77) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (80...81) = "("
        │   ├── rparen_loc: (85...86) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (88...91) = "end"
        ├── @ DefNode (location: (93...113))
        │   ├── name: :f
        │   ├── name_loc: (97...98) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (100...107))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (100...107))
        │   │   │       ├── parameters: (length: 2)
        │   │   │       │   ├── @ SplatNode (location: (101...103))
        │   │   │       │   │   ├── operator_loc: (101...102) = "*"
        │   │   │       │   │   └── expression:
        │   │   │       │   │       @ RequiredParameterNode (location: (102...103))
        │   │   │       │   │       └── name: :r
        │   │   │       │   └── @ RequiredParameterNode (location: (105...106))
        │   │   │       │       └── name: :p
        │   │   │       ├── opening_loc: (100...101) = "("
        │   │   │       └── closing_loc: (106...107) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:r, :p]
        │   ├── def_keyword_loc: (93...96) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (99...100) = "("
        │   ├── rparen_loc: (107...108) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (110...113) = "end"
        ├── @ DefNode (location: (115...134))
        │   ├── name: :f
        │   ├── name_loc: (119...120) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (122...128))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (122...128))
        │   │   │       ├── parameters: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (123...124))
        │   │   │       │   │   └── name: :a
        │   │   │       │   └── @ SplatNode (location: (126...127))
        │   │   │       │       ├── operator_loc: (126...127) = "*"
        │   │   │       │       └── expression: ∅
        │   │   │       ├── opening_loc: (122...123) = "("
        │   │   │       └── closing_loc: (127...128) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (115...118) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (121...122) = "("
        │   ├── rparen_loc: (128...129) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (131...134) = "end"
        ├── @ DefNode (location: (136...158))
        │   ├── name: :f
        │   ├── name_loc: (140...141) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (143...152))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (143...152))
        │   │   │       ├── parameters: (length: 3)
        │   │   │       │   ├── @ RequiredParameterNode (location: (144...145))
        │   │   │       │   │   └── name: :a
        │   │   │       │   ├── @ SplatNode (location: (147...148))
        │   │   │       │   │   ├── operator_loc: (147...148) = "*"
        │   │   │       │   │   └── expression: ∅
        │   │   │       │   └── @ RequiredParameterNode (location: (150...151))
        │   │   │       │       └── name: :p
        │   │   │       ├── opening_loc: (143...144) = "("
        │   │   │       └── closing_loc: (151...152) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :p]
        │   ├── def_keyword_loc: (136...139) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (142...143) = "("
        │   ├── rparen_loc: (152...153) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (155...158) = "end"
        ├── @ DefNode (location: (160...180))
        │   ├── name: :f
        │   ├── name_loc: (164...165) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (167...174))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (167...174))
        │   │   │       ├── parameters: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (168...169))
        │   │   │       │   │   └── name: :a
        │   │   │       │   └── @ SplatNode (location: (171...173))
        │   │   │       │       ├── operator_loc: (171...172) = "*"
        │   │   │       │       └── expression:
        │   │   │       │           @ RequiredParameterNode (location: (172...173))
        │   │   │       │           └── name: :r
        │   │   │       ├── opening_loc: (167...168) = "("
        │   │   │       └── closing_loc: (173...174) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :r]
        │   ├── def_keyword_loc: (160...163) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (166...167) = "("
        │   ├── rparen_loc: (174...175) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (177...180) = "end"
        ├── @ DefNode (location: (182...205))
        │   ├── name: :f
        │   ├── name_loc: (186...187) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (189...199))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (189...199))
        │   │   │       ├── parameters: (length: 3)
        │   │   │       │   ├── @ RequiredParameterNode (location: (190...191))
        │   │   │       │   │   └── name: :a
        │   │   │       │   ├── @ SplatNode (location: (193...195))
        │   │   │       │   │   ├── operator_loc: (193...194) = "*"
        │   │   │       │   │   └── expression:
        │   │   │       │   │       @ RequiredParameterNode (location: (194...195))
        │   │   │       │   │       └── name: :r
        │   │   │       │   └── @ RequiredParameterNode (location: (197...198))
        │   │   │       │       └── name: :p
        │   │   │       ├── opening_loc: (189...190) = "("
        │   │   │       └── closing_loc: (198...199) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :r, :p]
        │   ├── def_keyword_loc: (182...185) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (188...189) = "("
        │   ├── rparen_loc: (199...200) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (202...205) = "end"
        ├── @ DefNode (location: (207...227))
        │   ├── name: :f
        │   ├── name_loc: (211...212) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (214...221))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (214...221))
        │   │   │       ├── parameters: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (215...216))
        │   │   │       │   │   └── name: :a
        │   │   │       │   └── @ RequiredParameterNode (location: (218...220))
        │   │   │       │       └── name: :a1
        │   │   │       ├── opening_loc: (214...215) = "("
        │   │   │       └── closing_loc: (220...221) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :a1]
        │   ├── def_keyword_loc: (207...210) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (213...214) = "("
        │   ├── rparen_loc: (221...222) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (224...227) = "end"
        ├── @ DefNode (location: (229...252))
        │   ├── name: :f
        │   ├── name_loc: (233...234) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (236...246))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (236...242))
        │   │   │       ├── name: :foo
        │   │   │       ├── name_loc: (236...240) = "foo:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (241...242))
        │   │   │           └── flags: decimal
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (244...246))
        │   │       ├── name: :b
        │   │       ├── name_loc: (245...246) = "b"
        │   │       └── operator_loc: (244...245) = "&"
        │   ├── body: ∅
        │   ├── locals: [:foo, :b]
        │   ├── def_keyword_loc: (229...232) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (235...236) = "("
        │   ├── rparen_loc: (246...247) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (249...252) = "end"
        ├── @ DefNode (location: (254...292))
        │   ├── name: :f
        │   ├── name_loc: (258...259) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (261...286))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ KeywordParameterNode (location: (261...267))
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── name_loc: (261...265) = "foo:"
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (266...267))
        │   │   │   │       └── flags: decimal
        │   │   │   └── @ KeywordParameterNode (location: (269...275))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (269...273) = "bar:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (274...275))
        │   │   │           └── flags: decimal
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (277...282))
        │   │   │   ├── name: :baz
        │   │   │   ├── name_loc: (279...282) = "baz"
        │   │   │   └── operator_loc: (277...279) = "**"
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (284...286))
        │   │       ├── name: :b
        │   │       ├── name_loc: (285...286) = "b"
        │   │       └── operator_loc: (284...285) = "&"
        │   ├── body: ∅
        │   ├── locals: [:foo, :bar, :baz, :b]
        │   ├── def_keyword_loc: (254...257) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (260...261) = "("
        │   ├── rparen_loc: (286...287) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (289...292) = "end"
        ├── @ DefNode (location: (294...314))
        │   ├── name: :f
        │   ├── name_loc: (298...299) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (300...309))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (300...305))
        │   │   │   ├── name: :baz
        │   │   │   ├── name_loc: (302...305) = "baz"
        │   │   │   └── operator_loc: (300...302) = "**"
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (307...309))
        │   │       ├── name: :b
        │   │       ├── name_loc: (308...309) = "b"
        │   │       └── operator_loc: (307...308) = "&"
        │   ├── body: ∅
        │   ├── locals: [:baz, :b]
        │   ├── def_keyword_loc: (294...297) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (311...314) = "end"
        ├── @ DefNode (location: (316...332))
        │   ├── name: :f
        │   ├── name_loc: (320...321) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (322...327))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (322...323))
        │   │   │   ├── name: nil
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (322...323) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (325...327))
        │   │   │   ├── name: nil
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (325...327) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:*, :**]
        │   ├── def_keyword_loc: (316...319) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (329...332) = "end"
        ├── @ DefNode (location: (334...351))
        │   ├── name: :f
        │   ├── name_loc: (338...339) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (340...346))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (340...342))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (341...342) = "r"
        │   │   │   └── operator_loc: (340...341) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (344...346))
        │   │       ├── name: :b
        │   │       ├── name_loc: (345...346) = "b"
        │   │       └── operator_loc: (344...345) = "&"
        │   ├── body: ∅
        │   ├── locals: [:r, :b]
        │   ├── def_keyword_loc: (334...337) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (348...351) = "end"
        ├── @ DefNode (location: (353...373))
        │   ├── name: :f
        │   ├── name_loc: (357...358) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (359...368))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (359...361))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (360...361) = "r"
        │   │   │   └── operator_loc: (359...360) = "*"
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (363...364))
        │   │   │       └── name: :p
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (366...368))
        │   │       ├── name: :b
        │   │       ├── name_loc: (367...368) = "b"
        │   │       └── operator_loc: (366...367) = "&"
        │   ├── body: ∅
        │   ├── locals: [:r, :p, :b]
        │   ├── def_keyword_loc: (353...356) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (370...373) = "end"
        ├── @ DefNode (location: (375...386))
        │   ├── name: :f
        │   ├── name_loc: (379...380) = "f"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (375...378) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (383...386) = "end"
        ├── @ DefNode (location: (388...404))
        │   ├── name: :f
        │   ├── name_loc: (392...393) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (394...399))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (394...395))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (397...399))
        │   │       ├── name: :b
        │   │       ├── name_loc: (398...399) = "b"
        │   │       └── operator_loc: (397...398) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :b]
        │   ├── def_keyword_loc: (388...391) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (401...404) = "end"
        ├── @ DefNode (location: (406...426))
        │   ├── name: :f
        │   ├── name_loc: (410...411) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (412...421))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (412...413))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (415...417))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (416...417) = "r"
        │   │   │   └── operator_loc: (415...416) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (419...421))
        │   │       ├── name: :b
        │   │       ├── name_loc: (420...421) = "b"
        │   │       └── operator_loc: (419...420) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :r, :b]
        │   ├── def_keyword_loc: (406...409) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (423...426) = "end"
        ├── @ DefNode (location: (428...451))
        │   ├── name: :f
        │   ├── name_loc: (432...433) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (434...446))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (434...435))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (437...439))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (438...439) = "r"
        │   │   │   └── operator_loc: (437...438) = "*"
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (441...442))
        │   │   │       └── name: :p
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (444...446))
        │   │       ├── name: :b
        │   │       ├── name_loc: (445...446) = "b"
        │   │       └── operator_loc: (444...445) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :r, :p, :b]
        │   ├── def_keyword_loc: (428...431) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (448...451) = "end"
        ├── @ DefNode (location: (453...474))
        │   ├── name: :f
        │   ├── name_loc: (457...458) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (459...469))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (459...460))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (462...465))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (462...463) = "o"
        │   │   │       ├── operator_loc: (463...464) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (464...465))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (467...469))
        │   │       ├── name: :b
        │   │       ├── name_loc: (468...469) = "b"
        │   │       └── operator_loc: (467...468) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :o, :b]
        │   ├── def_keyword_loc: (453...456) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (471...474) = "end"
        ├── @ DefNode (location: (476...501))
        │   ├── name: :f
        │   ├── name_loc: (480...481) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (482...496))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (482...483))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (485...488))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (485...486) = "o"
        │   │   │       ├── operator_loc: (486...487) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (487...488))
        │   │   │           └── flags: decimal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (490...492))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (491...492) = "r"
        │   │   │   └── operator_loc: (490...491) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (494...496))
        │   │       ├── name: :b
        │   │       ├── name_loc: (495...496) = "b"
        │   │       └── operator_loc: (494...495) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :o, :r, :b]
        │   ├── def_keyword_loc: (476...479) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (498...501) = "end"
        ├── @ DefNode (location: (503...531))
        │   ├── name: :f
        │   ├── name_loc: (507...508) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (509...526))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (509...510))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (512...515))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (512...513) = "o"
        │   │   │       ├── operator_loc: (513...514) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (514...515))
        │   │   │           └── flags: decimal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (517...519))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (518...519) = "r"
        │   │   │   └── operator_loc: (517...518) = "*"
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (521...522))
        │   │   │       └── name: :p
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (524...526))
        │   │       ├── name: :b
        │   │       ├── name_loc: (525...526) = "b"
        │   │       └── operator_loc: (524...525) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :o, :r, :p, :b]
        │   ├── def_keyword_loc: (503...506) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (528...531) = "end"
        ├── @ DefNode (location: (533...557))
        │   ├── name: :f
        │   ├── name_loc: (537...538) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (539...552))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (539...540))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (542...545))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (542...543) = "o"
        │   │   │       ├── operator_loc: (543...544) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (544...545))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (547...548))
        │   │   │       └── name: :p
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (550...552))
        │   │       ├── name: :b
        │   │       ├── name_loc: (551...552) = "b"
        │   │       └── operator_loc: (550...551) = "&"
        │   ├── body: ∅
        │   ├── locals: [:a, :o, :p, :b]
        │   ├── def_keyword_loc: (533...536) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (554...557) = "end"
        ├── @ DefNode (location: (559...575))
        │   ├── name: :f
        │   ├── name_loc: (563...564) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (565...569))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (565...569))
        │   │   │       ├── name: :foo
        │   │   │       ├── name_loc: (565...569) = "foo:"
        │   │   │       └── value: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:foo]
        │   ├── def_keyword_loc: (559...562) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (572...575) = "end"
        ├── @ DefNode (location: (577...596))
        │   ├── name: :f
        │   ├── name_loc: (581...582) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (583...590))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (583...590))
        │   │   │       ├── name: :foo
        │   │   │       ├── name_loc: (583...587) = "foo:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (588...590))
        │   │   │           └── flags: decimal
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:foo]
        │   ├── def_keyword_loc: (577...580) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (593...596) = "end"
        ├── @ DefNode (location: (598...616))
        │   ├── name: :f
        │   ├── name_loc: (602...603) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (604...611))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (604...607))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (604...605) = "o"
        │   │   │       ├── operator_loc: (605...606) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (606...607))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (609...611))
        │   │       ├── name: :b
        │   │       ├── name_loc: (610...611) = "b"
        │   │       └── operator_loc: (609...610) = "&"
        │   ├── body: ∅
        │   ├── locals: [:o, :b]
        │   ├── def_keyword_loc: (598...601) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (613...616) = "end"
        ├── @ DefNode (location: (618...640))
        │   ├── name: :f
        │   ├── name_loc: (622...623) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (624...635))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (624...627))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (624...625) = "o"
        │   │   │       ├── operator_loc: (625...626) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (626...627))
        │   │   │           └── flags: decimal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (629...631))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (630...631) = "r"
        │   │   │   └── operator_loc: (629...630) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (633...635))
        │   │       ├── name: :b
        │   │       ├── name_loc: (634...635) = "b"
        │   │       └── operator_loc: (633...634) = "&"
        │   ├── body: ∅
        │   ├── locals: [:o, :r, :b]
        │   ├── def_keyword_loc: (618...621) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (637...640) = "end"
        ├── @ DefNode (location: (642...667))
        │   ├── name: :f
        │   ├── name_loc: (646...647) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (648...662))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (648...651))
        │   │   │       ├── name: :o
        │   │   │       ├── name_loc: (648...649) = "o"
        │   │   │       ├── operator_loc: (649...650) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (650...651))
        │   │   │           └── flags: decimal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (653...655))
        │   │   │   ├── name: :r
        │   │   │   ├── name_loc: (654...655) = "r"
        │   │   │   └── operator_loc: (653...654) = "*"
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (657...658))
        │   │   │       └── name: :p
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (660...662))
        │   │       ├── name: :b
        │   │       ├── name_loc: (661...662) = "b"
        │   │       └── operator_loc: (660...661) = "&"
        │   ├── body: ∅
        │   ├── locals: [:o, :r, :p, :b]
        │   ├── def_keyword_loc: (642...645) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (664...667) = "end"
        └── @ DefNode (location: (669...690))
            ├── name: :f
            ├── name_loc: (673...674) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (675...685))
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 1)
            │   │   └── @ OptionalParameterNode (location: (675...678))
            │   │       ├── name: :o
            │   │       ├── name_loc: (675...676) = "o"
            │   │       ├── operator_loc: (676...677) = "="
            │   │       └── value:
            │   │           @ IntegerNode (location: (677...678))
            │   │           └── flags: decimal
            │   ├── rest: ∅
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (680...681))
            │   │       └── name: :p
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block:
            │       @ BlockParameterNode (location: (683...685))
            │       ├── name: :b
            │       ├── name_loc: (684...685) = "b"
            │       └── operator_loc: (683...684) = "&"
            ├── body: ∅
            ├── locals: [:o, :p, :b]
            ├── def_keyword_loc: (669...672) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (687...690) = "end"
