---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "maintainer",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "pkgs",
       position: (3, 3),
      },
     ],
    },
    to: FunctionApplication {
     function: Variable {
      identifier: "import",
      position: (3, 10),
     },
     arguments: [
      Path {
       parts: [
        Raw {
         content: "./../../default.nix",
         position: (3, 17),
        },
       ],
       position: (3, 17),
      },
      Map {
       bindings: [],
       recursive: false,
       position: (3, 37),
      },
     ],
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "maintainer_",
       position: (4, 3),
      },
     ],
    },
    to: PropertyAccess {
     expression: Variable {
      identifier: "pkgs",
      position: (4, 17),
     },
     attribute_path: AttributePath {
      parts: [
       Raw {
        content: "lib",
        position: (4, 22),
       },
       Raw {
        content: "maintainers",
        position: (4, 26),
       },
       Expression {
        expression: Variable {
         identifier: "maintainer",
         position: (4, 40),
        },
       },
      ],
     },
     default: None,
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "packagesWith",
       position: (5, 3),
      },
     ],
    },
    to: Function {
     argument: Simple {
      identifier: "cond",
     },
     definition: Function {
      argument: Simple {
       identifier: "return",
      },
      definition: Function {
       argument: Simple {
        identifier: "prefix",
       },
       definition: Function {
        argument: Simple {
         identifier: "set",
        },
        definition: Parentheses {
         expression: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (6, 6),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "lib",
              position: (6, 11),
             },
             Raw {
              content: "flatten",
              position: (6, 15),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Parentheses {
            expression: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (7, 8),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "lib",
                 position: (7, 13),
                },
                Raw {
                 content: "mapAttrsToList",
                 position: (7, 17),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "name",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "pkg",
                 },
                 definition: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "result",
                       position: (10, 13),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "builtins",
                       position: (10, 22),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "tryEval",
                         position: (10, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Parentheses {
                       expression: IfThenElse {
                        predicate: BinaryOperation {
                         operator: LogicalAnd,
                         operands: [
                          FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (12, 20),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "lib",
                               position: (12, 25),
                              },
                              Raw {
                               content: "isDerivation",
                               position: (12, 29),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Variable {
                             identifier: "pkg",
                             position: (12, 42),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "cond",
                            position: (12, 49),
                           },
                           arguments: [
                            Variable {
                             identifier: "name",
                             position: (12, 54),
                            },
                            Variable {
                             identifier: "pkg",
                             position: (12, 59),
                            },
                           ],
                          },
                         ],
                         position: (12, 46),
                        },
                        then: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "builtins",
                           position: (16, 19),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "seq",
                             position: (16, 28),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "pkg",
                            position: (16, 32),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "outPath",
                              position: (16, 36),
                             },
                            ],
                           },
                           default: None,
                          },
                          List {
                           elements: [
                            Parentheses {
                             expression: FunctionApplication {
                              function: Variable {
                               identifier: "return",
                               position: (17, 24),
                              },
                              arguments: [
                               String {
                                parts: [
                                 Expression {
                                  expression: Variable {
                                   identifier: "prefix",
                                   position: (17, 34),
                                  },
                                 },
                                 Expression {
                                  expression: Variable {
                                   identifier: "name",
                                   position: (17, 43),
                                  },
                                 },
                                ],
                                position: (17, 31),
                               },
                              ],
                             },
                             position: (17, 23),
                            },
                           ],
                           position: (17, 21),
                          },
                         ],
                        },
                        else_: IfThenElse {
                         predicate: BinaryOperation {
                          operator: LogicalOr,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkg",
                             position: (18, 25),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "recurseForDerivations",
                               position: (18, 29),
                              },
                             ],
                            },
                            default: Some(
                             Variable {
                              identifier: "false",
                              position: (18, 54),
                             },
                            ),
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkg",
                             position: (18, 63),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "recurseForRelease",
                               position: (18, 67),
                              },
                             ],
                            },
                            default: Some(
                             Variable {
                              identifier: "false",
                              position: (18, 88),
                             },
                            ),
                           },
                          ],
                          position: (18, 60),
                         },
                         then: FunctionApplication {
                          function: Variable {
                           identifier: "packagesWith",
                           position: (20, 22),
                          },
                          arguments: [
                           Variable {
                            identifier: "cond",
                            position: (20, 35),
                           },
                           Variable {
                            identifier: "return",
                            position: (20, 40),
                           },
                           String {
                            parts: [
                             Expression {
                              expression: Variable {
                               identifier: "name",
                               position: (20, 50),
                              },
                             },
                             Raw {
                              content: ".",
                              position: (20, 55),
                             },
                            ],
                            position: (20, 47),
                           },
                           Variable {
                            identifier: "pkg",
                            position: (20, 58),
                           },
                          ],
                         },
                         else_: List {
                          elements: [],
                          position: (21, 22),
                         },
                         position: (18, 22),
                        },
                        position: (12, 17),
                       },
                       position: (11, 15),
                      },
                     ],
                    },
                   },
                  ],
                  target: IfThenElse {
                   predicate: PropertyAccess {
                    expression: Variable {
                     identifier: "result",
                     position: (24, 14),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "success",
                       position: (24, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                   then: PropertyAccess {
                    expression: Variable {
                     identifier: "result",
                     position: (24, 34),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "value",
                       position: (24, 41),
                      },
                     ],
                    },
                    default: None,
                   },
                   else_: List {
                    elements: [],
                    position: (25, 16),
                   },
                   position: (24, 11),
                  },
                  position: (9, 11),
                 },
                 position: (8, 16),
                },
                position: (8, 10),
               },
               position: (8, 9),
              },
              Variable {
               identifier: "set",
               position: (27, 9),
              },
             ],
            },
            position: (7, 7),
           },
          ],
         },
         position: (6, 5),
        },
        position: (5, 40),
       },
       position: (5, 32),
      },
      position: (5, 24),
     },
     position: (5, 18),
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "packages",
       position: (31, 3),
      },
     ],
    },
    to: FunctionApplication {
     function: Variable {
      identifier: "packagesWith",
      position: (31, 14),
     },
     arguments: [
      Parentheses {
       expression: Function {
        argument: Simple {
         identifier: "name",
        },
        definition: Function {
         argument: Simple {
          identifier: "pkg",
         },
         definition: Parentheses {
          expression: IfThenElse {
           predicate: BinaryOperation {
            operator: LogicalAnd,
            operands: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (34, 12),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "hasAttr",
                  position: (34, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "meta",
                  position: (34, 30),
                 },
                ],
                position: (34, 29),
               },
               Variable {
                identifier: "pkg",
                position: (34, 36),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (34, 43),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "hasAttr",
                  position: (34, 52),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "maintainers",
                  position: (34, 61),
                 },
                ],
                position: (34, 60),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkg",
                 position: (34, 74),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "meta",
                   position: (34, 78),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
            position: (34, 40),
           },
           then: Parentheses {
            expression: IfThenElse {
             predicate: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (37, 16),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "isList",
                  position: (37, 25),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "pkg",
                 position: (37, 32),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "meta",
                   position: (37, 36),
                  },
                  Raw {
                   content: "maintainers",
                   position: (37, 41),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             then: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (38, 18),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "elem",
                  position: (38, 27),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "maintainer_",
                position: (38, 32),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkg",
                 position: (38, 44),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "meta",
                   position: (38, 48),
                  },
                  Raw {
                   content: "maintainers",
                   position: (38, 53),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             else_: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "maintainer_",
                position: (39, 18),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkg",
                 position: (39, 33),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "meta",
                   position: (39, 37),
                  },
                  Raw {
                   content: "maintainers",
                   position: (39, 42),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (39, 30),
             },
             position: (37, 13),
            },
            position: (36, 11),
           },
           else_: Variable {
            identifier: "false",
            position: (41, 14),
           },
           position: (34, 9),
          },
          position: (33, 7),
         },
         position: (32, 12),
        },
        position: (32, 6),
       },
       position: (32, 5),
      },
      Parentheses {
       expression: Function {
        argument: Simple {
         identifier: "name",
        },
        definition: Variable {
         identifier: "name",
         position: (44, 12),
        },
        position: (44, 6),
       },
       position: (44, 5),
      },
      Parentheses {
       expression: String {
        parts: [],
        position: (45, 6),
       },
       position: (45, 5),
      },
      Variable {
       identifier: "pkgs",
       position: (46, 5),
      },
     ],
    },
   },
  ],
  target: FunctionApplication {
   function: PropertyAccess {
    expression: Variable {
     identifier: "pkgs",
     position: (49, 1),
    },
    attribute_path: AttributePath {
     parts: [
      Raw {
       content: "stdenv",
       position: (49, 6),
      },
      Raw {
       content: "mkDerivation",
       position: (49, 13),
      },
     ],
    },
    default: None,
   },
   arguments: [
    Map {
     bindings: [
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "name",
          position: (50, 3),
         },
        ],
       },
       to: String {
        parts: [
         Raw {
          content: "nixpkgs-update-script",
          position: (50, 11),
         },
        ],
        position: (50, 10),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "buildInputs",
          position: (51, 3),
         },
        ],
       },
       to: List {
        elements: [
         PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (51, 19),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "hydra-check",
             position: (51, 24),
            },
           ],
          },
          default: None,
         },
        ],
        position: (51, 17),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "buildCommand",
          position: (52, 3),
         },
        ],
       },
       to: String {
        parts: [
         Raw {
          content: "echo \"\"\necho \"----------------------------------------------------------------\"\necho \"\"\necho \"nix-shell maintainers/scripts/check-hydra-by-maintainer.nix --argstr maintainer SuperSandro2000\"\necho \"\"\necho \"----------------------------------------------------------------\"\nexit 1\n",
          position: (53, 1),
         },
        ],
        position: (52, 18),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "shellHook",
          position: (61, 3),
         },
        ],
       },
       to: String {
        parts: [
         Raw {
          content: "unset shellHook # do not contaminate nested shells\necho \"Please stand by\"\necho nix-shell -p hydra-check --run \"hydra-check ",
          position: (62, 1),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (64, 56),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "concatStringsSep",
               position: (64, 65),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: " ",
               position: (64, 83),
              },
             ],
             position: (64, 82),
            },
            Variable {
             identifier: "packages",
             position: (64, 86),
            },
           ],
          },
         },
         Raw {
          content: "\"\nnix-shell -p hydra-check --run \"hydra-check ",
          position: (64, 95),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (65, 51),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "concatStringsSep",
               position: (65, 60),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: " ",
               position: (65, 78),
              },
             ],
             position: (65, 77),
            },
            Variable {
             identifier: "packages",
             position: (65, 81),
            },
           ],
          },
         },
         Raw {
          content: "\"\nexit $?\n",
          position: (65, 90),
         },
        ],
        position: (61, 15),
       },
      },
     ],
     recursive: false,
     position: (49, 26),
    },
   ],
  },
  position: (2, 1),
 },
 position: (1, 1),
}