---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "nix",
         position: (7, 16),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nixPackage",
        position: (9, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (9, 16),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "package",
         position: (9, 20),
        },
        Raw {
         content: "out",
         position: (9, 28),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isNixAtLeast",
        position: (11, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "versionAtLeast",
       position: (11, 18),
      },
      arguments: [
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "getVersion",
          position: (11, 34),
         },
         arguments: [
          Variable {
           identifier: "nixPackage",
           position: (11, 45),
          },
         ],
        },
        position: (11, 33),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "makeNixBuildUser",
        position: (13, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "nr",
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "name",
            position: (14, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "nixbld",
            position: (14, 13),
           },
           Interpolation {
            expression: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (14, 21),
             },
             arguments: [
              Variable {
               identifier: "nr",
               position: (14, 30),
              },
             ],
            },
           },
          ],
          position: (14, 12),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "value",
            position: (15, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "description",
               position: (16, 7),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "Nix build user ",
               position: (16, 22),
              },
              Interpolation {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (16, 39),
                },
                arguments: [
                 Variable {
                  identifier: "nr",
                  position: (16, 48),
                 },
                ],
               },
              },
             ],
             position: (16, 21),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "uid",
               position: (23, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (23, 13),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "add",
                 position: (23, 22),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (23, 26),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "ids",
                  position: (23, 33),
                 },
                 Raw {
                  content: "uids",
                  position: (23, 37),
                 },
                 Raw {
                  content: "nixbld",
                  position: (23, 42),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "nr",
               position: (23, 49),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "isSystemUser",
               position: (24, 7),
              },
             ],
            },
            to: Variable {
             identifier: "true",
             position: (24, 22),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "group",
               position: (25, 7),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "nixbld",
               position: (25, 16),
              },
             ],
             position: (25, 15),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraGroups",
               position: (26, 7),
              },
             ],
            },
            to: List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nixbld",
                 position: (26, 24),
                },
               ],
               position: (26, 23),
              },
             ],
             position: (26, 21),
            },
           },
          ],
          recursive: false,
          position: (15, 13),
         },
        },
       ],
       recursive: false,
       position: (13, 26),
      },
      position: (13, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nixbldUsers",
        position: (30, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "listToAttrs",
       position: (30, 17),
      },
      arguments: [
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (30, 30),
         },
         arguments: [
          Variable {
           identifier: "makeNixBuildUser",
           position: (30, 34),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "range",
             position: (30, 52),
            },
            arguments: [
             Int {
              value: 1,
              position: (30, 58),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (30, 60),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "nrBuildUsers",
                 position: (30, 64),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (30, 51),
          },
         ],
        },
        position: (30, 29),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nixConf",
        position: (32, 3),
       },
      ],
     },
     to: Assert {
      expression: FunctionApplication {
       function: Variable {
        identifier: "isNixAtLeast",
        position: (33, 12),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "2.2",
           position: (33, 26),
          },
         ],
         position: (33, 25),
        },
       ],
      },
      target: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "mkValueString",
            position: (36, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "v",
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "v",
              position: (37, 12),
             },
             Variable {
              identifier: "null",
              position: (37, 17),
             },
            ],
            position: (37, 14),
           },
           then: String {
            parts: [],
            position: (37, 27),
           },
           else_: IfThenElse {
            predicate: FunctionApplication {
             function: Variable {
              identifier: "isInt",
              position: (38, 17),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (38, 23),
              },
             ],
            },
            then: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (38, 30),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (38, 39),
              },
             ],
            },
            else_: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "isBool",
               position: (39, 17),
              },
              arguments: [
               Variable {
                identifier: "v",
                position: (39, 24),
               },
              ],
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "boolToString",
               position: (39, 31),
              },
              arguments: [
               Variable {
                identifier: "v",
                position: (39, 44),
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "isFloat",
                position: (40, 17),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (40, 25),
                },
               ],
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "floatToString",
                position: (40, 32),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (40, 46),
                },
               ],
              },
              else_: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "isList",
                 position: (41, 17),
                },
                arguments: [
                 Variable {
                  identifier: "v",
                  position: (41, 24),
                 },
                ],
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (41, 31),
                },
                arguments: [
                 Variable {
                  identifier: "v",
                  position: (41, 40),
                 },
                ],
               },
               else_: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "isDerivation",
                  position: (42, 17),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (42, 30),
                  },
                 ],
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (42, 37),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (42, 46),
                  },
                 ],
                },
                else_: IfThenElse {
                 predicate: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (43, 17),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "isPath",
                      position: (43, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "v",
                    position: (43, 33),
                   },
                  ],
                 },
                 then: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (43, 40),
                  },
                  arguments: [
                   Variable {
                    identifier: "v",
                    position: (43, 49),
                   },
                  ],
                 },
                 else_: IfThenElse {
                  predicate: FunctionApplication {
                   function: Variable {
                    identifier: "isString",
                    position: (44, 17),
                   },
                   arguments: [
                    Variable {
                     identifier: "v",
                     position: (44, 26),
                    },
                   ],
                  },
                  then: Variable {
                   identifier: "v",
                   position: (44, 33),
                  },
                  else_: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "isCoercibleToString",
                     position: (45, 17),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (45, 37),
                     },
                    ],
                   },
                   then: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (45, 44),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (45, 53),
                     },
                    ],
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "abort",
                     position: (46, 14),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "The nix conf value: ",
                        position: (46, 21),
                       },
                       Interpolation {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toPretty",
                          position: (46, 43),
                         },
                         arguments: [
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (46, 52),
                          },
                          Variable {
                           identifier: "v",
                           position: (46, 55),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " can not be encoded",
                        position: (46, 57),
                       },
                      ],
                      position: (46, 20),
                     },
                    ],
                   },
                   position: (45, 14),
                  },
                  position: (44, 14),
                 },
                 position: (43, 14),
                },
                position: (42, 14),
               },
               position: (41, 14),
              },
              position: (40, 14),
             },
             position: (39, 14),
            },
            position: (38, 14),
           },
           position: (37, 9),
          },
          position: (36, 23),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "mkKeyValue",
            position: (48, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "k",
          },
          definition: Function {
           argument: Simple {
            identifier: "v",
           },
           definition: String {
            parts: [
             Interpolation {
              expression: FunctionApplication {
               function: Variable {
                identifier: "escape",
                position: (48, 29),
               },
               arguments: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "=",
                     position: (48, 39),
                    },
                   ],
                   position: (48, 38),
                  },
                 ],
                 position: (48, 36),
                },
                Variable {
                 identifier: "k",
                 position: (48, 44),
                },
               ],
              },
             },
             Raw {
              content: " = ",
              position: (48, 46),
             },
             Interpolation {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkValueString",
                position: (48, 51),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (48, 65),
                },
               ],
              },
             },
            ],
            position: (48, 26),
           },
           position: (48, 23),
          },
          position: (48, 20),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "mkKeyValuePairs",
            position: (50, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "attrs",
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (50, 32),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (50, 50),
              },
             ],
             position: (50, 49),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "mapAttrsToList",
               position: (50, 55),
              },
              arguments: [
               Variable {
                identifier: "mkKeyValue",
                position: (50, 70),
               },
               Variable {
                identifier: "attrs",
                position: (50, 81),
               },
              ],
             },
             position: (50, 54),
            },
           ],
          },
          position: (50, 25),
         },
        },
       ],
       target: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (53, 5),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "writeTextFile",
            position: (53, 10),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (54, 7),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "nix.conf",
               position: (54, 15),
              },
             ],
             position: (54, 14),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "text",
               position: (55, 7),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "# WARNING: this file is generated from the nix.* options in\n# your NixOS configuration, typically\n# /etc/nixos/configuration.nix.  Do not edit it!\n",
               position: (56, 1),
              },
              Interpolation {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "mkKeyValuePairs",
                 position: (59, 11),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (59, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "settings",
                     position: (59, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (59, 40),
              },
              Interpolation {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (60, 11),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "extraOptions",
                   position: (60, 15),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (60, 28),
              },
             ],
             position: (55, 14),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "checkPhase",
               position: (62, 7),
              },
             ],
            },
            to: IfThenElse {
             predicate: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (63, 12),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "stdenv",
                   position: (63, 17),
                  },
                  Raw {
                   content: "hostPlatform",
                   position: (63, 24),
                  },
                 ],
                },
                default: None,
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (63, 40),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "stdenv",
                   position: (63, 45),
                  },
                  Raw {
                   content: "buildPlatform",
                   position: (63, 52),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (63, 37),
             },
             then: String {
              parts: [
               Raw {
                content: "echo \"Ignoring validation for cross-compilation\"\n",
                position: (64, 1),
               },
              ],
              position: (63, 71),
             },
             else_: String {
              parts: [
               Raw {
                content: "echo \"Validating generated nix.conf\"\nln -s $out ./nix.conf\nset -e\nset +o pipefail\nNIX_CONF_DIR=$PWD \\\n  ",
                position: (67, 1),
               },
               Interpolation {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (72, 15),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "package",
                    position: (72, 19),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/nix show-config ",
                position: (72, 27),
               },
               Interpolation {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (72, 50),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "isNixAtLeast",
                     position: (72, 66),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "2.3pre",
                        position: (72, 80),
                       },
                      ],
                      position: (72, 79),
                     },
                    ],
                   },
                   position: (72, 65),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "--no-net",
                     position: (72, 90),
                    },
                   ],
                   position: (72, 89),
                  },
                 ],
                },
               },
               Raw {
                content: " \\\n    ",
                position: (72, 100),
               },
               Interpolation {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (73, 17),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "isNixAtLeast",
                     position: (73, 33),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "2.4pre",
                        position: (73, 47),
                       },
                      ],
                      position: (73, 46),
                     },
                    ],
                   },
                   position: (73, 32),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "--option experimental-features nix-command",
                     position: (73, 57),
                    },
                   ],
                   position: (73, 56),
                  },
                 ],
                },
               },
               Raw {
                content: " \\\n  |& sed -e 's/^warning:/error:/' \\\n  | (! grep ",
                position: (73, 101),
               },
               Raw {
                content: "'",
                position: (75, 23),
               },
               Interpolation {
                expression: IfThenElse {
                 predicate: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (75, 29),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "checkConfig",
                     position: (75, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                 then: String {
                  parts: [
                   Raw {
                    content: "^error:",
                    position: (75, 51),
                   },
                  ],
                  position: (75, 50),
                 },
                 else_: String {
                  parts: [
                   Raw {
                    content: "^error: unknown setting",
                    position: (75, 66),
                   },
                  ],
                  position: (75, 65),
                 },
                 position: (75, 26),
                },
               },
               Raw {
                content: "')\nset -o pipefail\n",
                position: (75, 91),
               },
              ],
              position: (66, 14),
             },
             position: (63, 9),
            },
           },
          ],
          recursive: false,
          position: (53, 24),
         },
        ],
       },
       position: (34, 5),
      },
      position: (33, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "legacyConfMappings",
        position: (80, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "useSandbox",
           position: (81, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "sandbox",
           position: (81, 19),
          },
         ],
         position: (81, 18),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "buildCores",
           position: (82, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "cores",
           position: (82, 19),
          },
         ],
         position: (82, 18),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "maxJobs",
           position: (83, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "max-jobs",
           position: (83, 16),
          },
         ],
         position: (83, 15),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "sandboxPaths",
           position: (84, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "extra-sandbox-paths",
           position: (84, 21),
          },
         ],
         position: (84, 20),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "binaryCaches",
           position: (85, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "substituters",
           position: (85, 21),
          },
         ],
         position: (85, 20),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "trustedBinaryCaches",
           position: (86, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "trusted-substituters",
           position: (86, 28),
          },
         ],
         position: (86, 27),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "binaryCachePublicKeys",
           position: (87, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "trusted-public-keys",
           position: (87, 30),
          },
         ],
         position: (87, 29),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "autoOptimiseStore",
           position: (88, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "auto-optimise-store",
           position: (88, 26),
          },
         ],
         position: (88, 25),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "requireSignedBinaryCaches",
           position: (89, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "require-sigs",
           position: (89, 34),
          },
         ],
         position: (89, 33),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "trustedUsers",
           position: (90, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "trusted-users",
           position: (90, 21),
          },
         ],
         position: (90, 20),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "allowedUsers",
           position: (91, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "allowed-users",
           position: (91, 21),
          },
         ],
         position: (91, 20),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "systemFeatures",
           position: (92, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "system-features",
           position: (92, 23),
          },
         ],
         position: (92, 22),
        },
       },
      ],
      recursive: false,
      position: (80, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "semanticConfType",
        position: (95, 3),
       },
      ],
     },
     to: With {
      expression: Variable {
       identifier: "types",
       position: (95, 27),
      },
      target: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "confAtom",
            position: (97, 7),
           },
          ],
         },
         to: BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "nullOr",
             position: (97, 18),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "oneOf",
                position: (98, 10),
               },
               arguments: [
                List {
                 elements: [
                  Variable {
                   identifier: "bool",
                   position: (99, 11),
                  },
                  Variable {
                   identifier: "int",
                   position: (100, 11),
                  },
                  Variable {
                   identifier: "float",
                   position: (101, 11),
                  },
                  Variable {
                   identifier: "str",
                   position: (102, 11),
                  },
                  Variable {
                   identifier: "path",
                   position: (103, 11),
                  },
                  Variable {
                   identifier: "package",
                   position: (104, 11),
                  },
                 ],
                 position: (98, 16),
                },
               ],
              },
              position: (98, 9),
             },
            ],
           },
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (106, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Nix config atom (null, bool, int, float, str, path or package)",
                 position: (106, 24),
                },
               ],
               position: (106, 23),
              },
             },
            ],
            recursive: false,
            position: (105, 15),
           },
          ],
          position: (105, 12),
         },
        },
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "attrsOf",
         position: (109, 5),
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "either",
            position: (109, 14),
           },
           arguments: [
            Variable {
             identifier: "confAtom",
             position: (109, 21),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "listOf",
               position: (109, 31),
              },
              arguments: [
               Variable {
                identifier: "confAtom",
                position: (109, 38),
               },
              ],
             },
             position: (109, 30),
            },
           ],
          },
          position: (109, 13),
         },
        ],
       },
       position: (96, 5),
      },
      position: (95, 22),
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "imports",
         position: (114, 3),
        },
       ],
      },
      to: BinaryOperation {
       operator: Concatenation,
       operands: [
        List {
         elements: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkRenamedOptionModuleWith",
             position: (115, 6),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "sinceRelease",
                   position: (115, 34),
                  },
                 ],
                },
                to: Int {
                 value: 2003,
                 position: (115, 49),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "from",
                   position: (115, 55),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (115, 65),
                    },
                   ],
                   position: (115, 64),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "useChroot",
                     position: (115, 71),
                    },
                   ],
                   position: (115, 70),
                  },
                 ],
                 position: (115, 62),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "to",
                   position: (115, 85),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (115, 93),
                    },
                   ],
                   position: (115, 92),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "useSandbox",
                     position: (115, 99),
                    },
                   ],
                   position: (115, 98),
                  },
                 ],
                 position: (115, 90),
                },
               },
              ],
              recursive: false,
              position: (115, 32),
             },
            ],
           },
           position: (115, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkRenamedOptionModuleWith",
             position: (116, 6),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "sinceRelease",
                   position: (116, 34),
                  },
                 ],
                },
                to: Int {
                 value: 2003,
                 position: (116, 49),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "from",
                   position: (116, 55),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (116, 65),
                    },
                   ],
                   position: (116, 64),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "chrootDirs",
                     position: (116, 71),
                    },
                   ],
                   position: (116, 70),
                  },
                 ],
                 position: (116, 62),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "to",
                   position: (116, 86),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (116, 94),
                    },
                   ],
                   position: (116, 93),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "sandboxPaths",
                     position: (116, 100),
                    },
                   ],
                   position: (116, 99),
                  },
                 ],
                 position: (116, 91),
                },
               },
              ],
              recursive: false,
              position: (116, 32),
             },
            ],
           },
           position: (116, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkRenamedOptionModuleWith",
             position: (117, 6),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "sinceRelease",
                   position: (117, 34),
                  },
                 ],
                },
                to: Int {
                 value: 2205,
                 position: (117, 49),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "from",
                   position: (117, 55),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (117, 65),
                    },
                   ],
                   position: (117, 64),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "daemonIONiceLevel",
                     position: (117, 71),
                    },
                   ],
                   position: (117, 70),
                  },
                 ],
                 position: (117, 62),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "to",
                   position: (117, 93),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (117, 101),
                    },
                   ],
                   position: (117, 100),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "daemonIOSchedPriority",
                     position: (117, 107),
                    },
                   ],
                   position: (117, 106),
                  },
                 ],
                 position: (117, 98),
                },
               },
              ],
              recursive: false,
              position: (117, 32),
             },
            ],
           },
           position: (117, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkRemovedOptionModule",
             position: (118, 6),
            },
            arguments: [
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "nix",
                  position: (118, 31),
                 },
                ],
                position: (118, 30),
               },
               String {
                parts: [
                 Raw {
                  content: "daemonNiceLevel",
                  position: (118, 37),
                 },
                ],
                position: (118, 36),
               },
              ],
              position: (118, 28),
             },
             String {
              parts: [
               Raw {
                content: "Consider nix.daemonCPUSchedPolicy instead.",
                position: (118, 57),
               },
              ],
              position: (118, 56),
             },
            ],
           },
           position: (118, 5),
          },
         ],
         position: (114, 13),
        },
        FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (119, 8),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "oldConf",
            },
            definition: Function {
             argument: Simple {
              identifier: "newConf",
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "mkRenamedOptionModuleWith",
               position: (119, 42),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "sinceRelease",
                     position: (119, 70),
                    },
                   ],
                  },
                  to: Int {
                   value: 2205,
                   position: (119, 85),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "from",
                     position: (119, 91),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "nix",
                       position: (119, 101),
                      },
                     ],
                     position: (119, 100),
                    },
                    Variable {
                     identifier: "oldConf",
                     position: (119, 106),
                    },
                   ],
                   position: (119, 98),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "to",
                     position: (119, 117),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "nix",
                       position: (119, 125),
                      },
                     ],
                     position: (119, 124),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "settings",
                       position: (119, 131),
                      },
                     ],
                     position: (119, 130),
                    },
                    Variable {
                     identifier: "newConf",
                     position: (119, 141),
                    },
                   ],
                   position: (119, 122),
                  },
                 },
                ],
                recursive: false,
                position: (119, 68),
               },
              ],
             },
             position: (119, 33),
            },
            position: (119, 24),
           },
           position: (119, 23),
          },
          Variable {
           identifier: "legacyConfMappings",
           position: (119, 155),
          },
         ],
        },
       ],
       position: (119, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (123, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "nix",
            position: (125, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (127, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (127, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (128, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (128, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (128, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (129, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (129, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (130, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to enable Nix.\nDisabling Nix makes the system hard to modify and the Nix programs and configuration will not be made available by NixOS itself.\n",
                    position: (131, 1),
                   },
                  ],
                  position: (130, 23),
                 },
                },
               ],
               recursive: false,
               position: (127, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "package",
               position: (136, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (136, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (137, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "package",
                     position: (137, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (138, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (138, 19),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "nix",
                     position: (138, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (139, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (139, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.nix",
                      position: (139, 42),
                     },
                    ],
                    position: (139, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (140, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "This option specifies the Nix package instance to use throughout the system.\n",
                    position: (141, 1),
                   },
                  ],
                  position: (140, 23),
                 },
                },
               ],
               recursive: false,
               position: (136, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "distributedBuilds",
               position: (145, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (145, 27),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (146, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (146, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (147, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (147, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (148, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Whether to distribute builds to the machines listed in\n<option>nix.buildMachines</option>.\n",
                    position: (149, 1),
                   },
                  ],
                  position: (148, 23),
                 },
                },
               ],
               recursive: false,
               position: (145, 36),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "daemonCPUSchedPolicy",
               position: (154, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (154, 30),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (155, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (155, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "enum",
                      position: (155, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "other",
                        position: (155, 30),
                       },
                      ],
                      position: (155, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "batch",
                        position: (155, 38),
                       },
                      ],
                      position: (155, 37),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "idle",
                        position: (155, 46),
                       },
                      ],
                      position: (155, 45),
                     },
                    ],
                    position: (155, 27),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (156, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "other",
                    position: (156, 20),
                   },
                  ],
                  position: (156, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (157, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "batch",
                    position: (157, 20),
                   },
                  ],
                  position: (157, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (158, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Nix daemon process CPU scheduling policy. This policy propagates to\nbuild processes. <literal>other</literal> is the default scheduling\npolicy for regular tasks. The <literal>batch</literal> policy is\nsimilar to <literal>other</literal>, but optimised for\nnon-interactive tasks. <literal>idle</literal> is for extremely\nlow-priority tasks that should only be run when no other task\nrequires CPU time.\n\nPlease note that while using the <literal>idle</literal> policy may\ngreatly improve responsiveness of a system performing expensive\nbuilds, it may also slow down and potentially starve crucial\nconfiguration updates during load.\n\n<literal>idle</literal> may therefore be a sensible policy for\nsystems that experience only intermittent phases of high CPU load,\nsuch as desktop or portable computers used interactively. Other\nsystems should use the <literal>other</literal> or\n<literal>batch</literal> policy instead.\n\nFor more fine-grained resource control, please refer to\n<citerefentry><refentrytitle>systemd.resource-control\n</refentrytitle><manvolnum>5</manvolnum></citerefentry> and adjust\n<option>systemd.services.nix-daemon</option> directly.\n",
                    position: (159, 1),
                   },
                  ],
                  position: (158, 23),
                 },
                },
               ],
               recursive: false,
               position: (154, 39),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "daemonIOSchedClass",
               position: (185, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (185, 28),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (186, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (186, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "enum",
                      position: (186, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "best-effort",
                        position: (186, 30),
                       },
                      ],
                      position: (186, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "idle",
                        position: (186, 44),
                       },
                      ],
                      position: (186, 43),
                     },
                    ],
                    position: (186, 27),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (187, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "best-effort",
                    position: (187, 20),
                   },
                  ],
                  position: (187, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (188, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "idle",
                    position: (188, 20),
                   },
                  ],
                  position: (188, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (189, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Nix daemon process I/O scheduling class. This class propagates to\nbuild processes. <literal>best-effort</literal> is the default\nclass for regular tasks. The <literal>idle</literal> class is for\nextremely low-priority tasks that should only perform I/O when no\nother task does.\n\nPlease note that while using the <literal>idle</literal> scheduling\nclass can improve responsiveness of a system performing expensive\nbuilds, it might also slow down or starve crucial configuration\nupdates during load.\n\n<literal>idle</literal> may therefore be a sensible class for\nsystems that experience only intermittent phases of high I/O load,\nsuch as desktop or portable computers used interactively. Other\nsystems should use the <literal>best-effort</literal> class.\n",
                    position: (190, 1),
                   },
                  ],
                  position: (189, 23),
                 },
                },
               ],
               recursive: false,
               position: (185, 37),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "daemonIOSchedPriority",
               position: (208, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (208, 31),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (209, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (209, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (209, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (210, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 0,
                  position: (210, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (211, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 1,
                  position: (211, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (212, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Nix daemon process I/O scheduling priority. This priority propagates\nto build processes. The supported priorities depend on the\nscheduling policy: With idle, priorities are not used in scheduling\ndecisions. best-effort supports values in the range 0 (high) to 7\n(low).\n",
                    position: (213, 1),
                   },
                  ],
                  position: (212, 23),
                 },
                },
               ],
               recursive: false,
               position: (208, 40),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "buildMachines",
               position: (221, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (221, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (222, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (222, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (222, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (222, 30),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "submodule",
                         position: (222, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "options",
                            position: (223, 11),
                           },
                          ],
                         },
                         to: Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "hostName",
                               position: (224, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (224, 24),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (225, 15),
                                   },
                                  ],
                                 },
                                 to: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (225, 22),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (225, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (226, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "nixbuilder.example.org",
                                    position: (226, 26),
                                   },
                                  ],
                                  position: (226, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (227, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The hostname of the build machine.\n",
                                    position: (228, 1),
                                   },
                                  ],
                                  position: (227, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (224, 33),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "system",
                               position: (231, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (231, 22),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (232, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (232, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "nullOr",
                                      position: (232, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (232, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (232, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (233, 15),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (233, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (234, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "x86_64-linux",
                                    position: (234, 26),
                                   },
                                  ],
                                  position: (234, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (235, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The system type the build machine can execute derivations on.\nEither this attribute or <varname>systems</varname> must be\npresent, where <varname>system</varname> takes precedence if\nboth are set.\n",
                                    position: (236, 1),
                                   },
                                  ],
                                  position: (235, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (231, 31),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "systems",
                               position: (242, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (242, 23),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (243, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (243, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "listOf",
                                      position: (243, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (243, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (243, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (244, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [],
                                  position: (244, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (245, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "x86_64-linux",
                                      position: (245, 28),
                                     },
                                    ],
                                    position: (245, 27),
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "aarch64-linux",
                                      position: (245, 43),
                                     },
                                    ],
                                    position: (245, 42),
                                   },
                                  ],
                                  position: (245, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (246, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The system types the build machine can execute derivations on.\nEither this attribute or <varname>system</varname> must be\npresent, where <varname>system</varname> takes precedence if\nboth are set.\n",
                                    position: (247, 1),
                                   },
                                  ],
                                  position: (246, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (242, 32),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "sshUser",
                               position: (253, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (253, 23),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (254, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (254, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "nullOr",
                                      position: (254, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (254, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (254, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (255, 15),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (255, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (256, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "builder",
                                    position: (256, 26),
                                   },
                                  ],
                                  position: (256, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (257, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The username to log in as on the remote host. This user must be\nable to log in and run nix commands non-interactively. It must\nalso be privileged to build derivations, so must be included in\n<option>nix.settings.trusted-users</option>.\n",
                                    position: (258, 1),
                                   },
                                  ],
                                  position: (257, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (253, 32),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "sshKey",
                               position: (264, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (264, 22),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (265, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (265, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "nullOr",
                                      position: (265, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (265, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (265, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (266, 15),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (266, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (267, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "/root/.ssh/id_buildhost_builduser",
                                    position: (267, 26),
                                   },
                                  ],
                                  position: (267, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (268, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The path to the SSH private key with which to authenticate on\nthe build machine. The private key must not have a passphrase.\nIf null, the building user (root on NixOS machines) must have an\nappropriate ssh configuration to log in non-interactively.\n\nNote that for security reasons, this path must point to a file\nin the local filesystem, *not* to the nix store.\n",
                                    position: (269, 1),
                                   },
                                  ],
                                  position: (268, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (264, 31),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "maxJobs",
                               position: (278, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (278, 23),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (279, 15),
                                   },
                                  ],
                                 },
                                 to: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (279, 22),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "int",
                                     position: (279, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (280, 15),
                                   },
                                  ],
                                 },
                                 to: Int {
                                  value: 1,
                                  position: (280, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (281, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The number of concurrent jobs the build machine supports. The\nbuild machine will enforce its own limits, but this allows hydra\nto schedule better since there is no work-stealing between build\nmachines.\n",
                                    position: (282, 1),
                                   },
                                  ],
                                  position: (281, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (278, 32),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "speedFactor",
                               position: (288, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (288, 27),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (289, 15),
                                   },
                                  ],
                                 },
                                 to: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (289, 22),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "int",
                                     position: (289, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (290, 15),
                                   },
                                  ],
                                 },
                                 to: Int {
                                  value: 1,
                                  position: (290, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (291, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The relative speed of this builder. This is an arbitrary integer\nthat indicates the speed of this builder, relative to other\nbuilders. Higher is faster.\n",
                                    position: (292, 1),
                                   },
                                  ],
                                  position: (291, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (288, 36),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "mandatoryFeatures",
                               position: (297, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (297, 33),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (298, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (298, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "listOf",
                                      position: (298, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (298, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (298, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (299, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [],
                                  position: (299, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (300, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "big-parallel",
                                      position: (300, 28),
                                     },
                                    ],
                                    position: (300, 27),
                                   },
                                  ],
                                  position: (300, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (301, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "A list of features mandatory for this builder. The builder will\nbe ignored for derivations that don't require all features in\nthis list. All mandatory features are automatically included in\n<varname>supportedFeatures</varname>.\n",
                                    position: (302, 1),
                                   },
                                  ],
                                  position: (301, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (297, 42),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "supportedFeatures",
                               position: (308, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (308, 33),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (309, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (309, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "listOf",
                                      position: (309, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (309, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (309, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (310, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [],
                                  position: (310, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (311, 15),
                                   },
                                  ],
                                 },
                                 to: List {
                                  elements: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "kvm",
                                      position: (311, 28),
                                     },
                                    ],
                                    position: (311, 27),
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "big-parallel",
                                      position: (311, 34),
                                     },
                                    ],
                                    position: (311, 33),
                                   },
                                  ],
                                  position: (311, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (312, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "A list of features supported by this builder. The builder will\nbe ignored for derivations that require features not in this\nlist.\n",
                                    position: (313, 1),
                                   },
                                  ],
                                  position: (312, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (308, 42),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "publicHostKey",
                               position: (318, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (318, 29),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (319, 15),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (319, 22),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "nullOr",
                                      position: (319, 28),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (319, 35),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "str",
                                       position: (319, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (320, 15),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (320, 25),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (321, 15),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "The (base64-encoded) public host key of this builder. The field\nis calculated via <command>base64 -w0 /etc/ssh/ssh_host_type_key.pub</command>.\nIf null, SSH will use its regular known-hosts file when connecting.\n",
                                    position: (322, 1),
                                   },
                                  ],
                                  position: (321, 29),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (318, 38),
                              },
                             ],
                            },
                           },
                          ],
                          recursive: false,
                          position: (223, 21),
                         },
                        },
                       ],
                       recursive: false,
                       position: (222, 46),
                      },
                     ],
                    },
                    position: (222, 29),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (329, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (329, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (330, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "This option lists the machines to be used if distributed builds are\nenabled (see <option>nix.distributedBuilds</option>).\nNix will perform derivations on those machines via SSH by copying the\ninputs to the Nix store on the remote machine, starting the build,\nthen copying the output back to the local Nix store.\n",
                    position: (331, 1),
                   },
                  ],
                  position: (330, 23),
                 },
                },
               ],
               recursive: false,
               position: (221, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "envVars",
               position: (340, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (340, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (341, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (341, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "attrs",
                     position: (341, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "internal",
                    position: (342, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (342, 20),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (343, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (343, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (344, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Environment variables used by Nix.",
                    position: (344, 24),
                   },
                  ],
                  position: (344, 23),
                 },
                },
               ],
               recursive: false,
               position: (340, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "nrBuildUsers",
               position: (347, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (347, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (348, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (348, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (348, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (349, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Number of <literal>nixbld</literal> user accounts created to\nperform secure concurrent builds.  If you receive an error\nmessage saying that “all build users are currently in use”,\nyou should increase this value.\n",
                    position: (350, 1),
                   },
                  ],
                  position: (349, 23),
                 },
                },
               ],
               recursive: false,
               position: (347, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "readOnlyStore",
               position: (357, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (357, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (358, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (358, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (358, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (359, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (359, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (360, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "If set, NixOS will enforce the immutability of the Nix store\nby making <filename>/nix/store</filename> a read-only bind\nmount.  Nix will automatically make the store writable when\nneeded.\n",
                    position: (361, 1),
                   },
                  ],
                  position: (360, 23),
                 },
                },
               ],
               recursive: false,
               position: (357, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "nixPath",
               position: (368, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (368, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (369, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (369, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (369, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (369, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (369, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (370, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "nixpkgs=/nix/var/nix/profiles/per-user/root/channels/nixos",
                      position: (371, 12),
                     },
                    ],
                    position: (371, 11),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "nixos-config=/etc/nixos/configuration.nix",
                      position: (372, 12),
                     },
                    ],
                    position: (372, 11),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/nix/var/nix/profiles/per-user/root/channels",
                      position: (373, 12),
                     },
                    ],
                    position: (373, 11),
                   },
                  ],
                  position: (370, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (375, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The default Nix expression search path, used by the Nix\nevaluator to look up paths enclosed in angle brackets\n(e.g. <literal>&lt;nixpkgs&gt;</literal>).\n",
                    position: (376, 1),
                   },
                  ],
                  position: (375, 23),
                 },
                },
               ],
               recursive: false,
               position: (368, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "checkConfig",
               position: (382, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (382, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (383, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (383, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (383, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (384, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (384, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (385, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "If enabled (the default), checks for data type mismatches and that Nix\ncan parse the generated nix.conf.\n",
                    position: (386, 1),
                   },
                  ],
                  position: (385, 23),
                 },
                },
               ],
               recursive: false,
               position: (382, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "registry",
               position: (391, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (391, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (392, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (392, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "attrsOf",
                      position: (392, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (392, 31),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "submodule",
                         position: (392, 37),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Parentheses {
                       expression: LetIn {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "referenceAttrs",
                             position: (394, 13),
                            },
                           ],
                          },
                          to: With {
                           expression: Variable {
                            identifier: "types",
                            position: (394, 35),
                           },
                           target: FunctionApplication {
                            function: Variable {
                             identifier: "attrsOf",
                             position: (394, 42),
                            },
                            arguments: [
                             Parentheses {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "oneOf",
                                position: (394, 51),
                               },
                               arguments: [
                                List {
                                 elements: [
                                  Variable {
                                   identifier: "str",
                                   position: (395, 15),
                                  },
                                  Variable {
                                   identifier: "int",
                                   position: (396, 15),
                                  },
                                  Variable {
                                   identifier: "bool",
                                   position: (397, 15),
                                  },
                                  Variable {
                                   identifier: "package",
                                   position: (398, 15),
                                  },
                                 ],
                                 position: (394, 57),
                                },
                               ],
                              },
                              position: (394, 50),
                             },
                            ],
                           },
                           position: (394, 30),
                          },
                         },
                        ],
                        target: Function {
                         argument: Destructured {
                          identifier: None,
                          arguments: [
                           DestructuredArgument {
                            identifier: "config",
                            default: None,
                           },
                           DestructuredArgument {
                            identifier: "name",
                            default: None,
                           },
                          ],
                          ellipsis: true,
                         },
                         definition: Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "options",
                               position: (403, 13),
                              },
                             ],
                            },
                            to: Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "from",
                                  position: (404, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkOption",
                                 position: (404, 22),
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "type",
                                       position: (405, 17),
                                      },
                                     ],
                                    },
                                    to: Variable {
                                     identifier: "referenceAttrs",
                                     position: (405, 24),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "example",
                                       position: (406, 17),
                                      },
                                     ],
                                    },
                                    to: Map {
                                     bindings: [
                                      Binding {
                                       from: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "type",
                                          position: (406, 29),
                                         },
                                        ],
                                       },
                                       to: String {
                                        parts: [
                                         Raw {
                                          content: "indirect",
                                          position: (406, 37),
                                         },
                                        ],
                                        position: (406, 36),
                                       },
                                      },
                                      Binding {
                                       from: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "id",
                                          position: (406, 48),
                                         },
                                        ],
                                       },
                                       to: String {
                                        parts: [
                                         Raw {
                                          content: "nixpkgs",
                                          position: (406, 54),
                                         },
                                        ],
                                        position: (406, 53),
                                       },
                                      },
                                     ],
                                     recursive: false,
                                     position: (406, 27),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "description",
                                       position: (407, 17),
                                      },
                                     ],
                                    },
                                    to: String {
                                     parts: [
                                      Raw {
                                       content: "The flake reference to be rewritten.",
                                       position: (407, 32),
                                      },
                                     ],
                                     position: (407, 31),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (404, 31),
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "to",
                                  position: (409, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkOption",
                                 position: (409, 20),
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "type",
                                       position: (410, 17),
                                      },
                                     ],
                                    },
                                    to: Variable {
                                     identifier: "referenceAttrs",
                                     position: (410, 24),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "example",
                                       position: (411, 17),
                                      },
                                     ],
                                    },
                                    to: Map {
                                     bindings: [
                                      Binding {
                                       from: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "type",
                                          position: (411, 29),
                                         },
                                        ],
                                       },
                                       to: String {
                                        parts: [
                                         Raw {
                                          content: "github",
                                          position: (411, 37),
                                         },
                                        ],
                                        position: (411, 36),
                                       },
                                      },
                                      Binding {
                                       from: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "owner",
                                          position: (411, 46),
                                         },
                                        ],
                                       },
                                       to: String {
                                        parts: [
                                         Raw {
                                          content: "my-org",
                                          position: (411, 55),
                                         },
                                        ],
                                        position: (411, 54),
                                       },
                                      },
                                      Binding {
                                       from: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "repo",
                                          position: (411, 64),
                                         },
                                        ],
                                       },
                                       to: String {
                                        parts: [
                                         Raw {
                                          content: "my-nixpkgs",
                                          position: (411, 72),
                                         },
                                        ],
                                        position: (411, 71),
                                       },
                                      },
                                     ],
                                     recursive: false,
                                     position: (411, 27),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "description",
                                       position: (412, 17),
                                      },
                                     ],
                                    },
                                    to: String {
                                     parts: [
                                      Raw {
                                       content: "The flake reference <option>from</option> is rewritten to.",
                                       position: (412, 32),
                                      },
                                     ],
                                     position: (412, 31),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (409, 29),
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "flake",
                                  position: (414, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkOption",
                                 position: (414, 23),
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "type",
                                       position: (415, 17),
                                      },
                                     ],
                                    },
                                    to: FunctionApplication {
                                     function: PropertyAccess {
                                      expression: Variable {
                                       identifier: "types",
                                       position: (415, 24),
                                      },
                                      attribute_path: AttributePath {
                                       parts: [
                                        Raw {
                                         content: "nullOr",
                                         position: (415, 30),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                     arguments: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "types",
                                        position: (415, 37),
                                       },
                                       attribute_path: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "attrs",
                                          position: (415, 43),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     ],
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "default",
                                       position: (416, 17),
                                      },
                                     ],
                                    },
                                    to: Variable {
                                     identifier: "null",
                                     position: (416, 27),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "example",
                                       position: (417, 17),
                                      },
                                     ],
                                    },
                                    to: FunctionApplication {
                                     function: Variable {
                                      identifier: "literalExpression",
                                      position: (417, 27),
                                     },
                                     arguments: [
                                      String {
                                       parts: [
                                        Raw {
                                         content: "nixpkgs",
                                         position: (417, 46),
                                        },
                                       ],
                                       position: (417, 45),
                                      },
                                     ],
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "description",
                                       position: (418, 17),
                                      },
                                     ],
                                    },
                                    to: String {
                                     parts: [
                                      Raw {
                                       content: "The flake input <option>from</option> is rewritten to.\n",
                                       position: (419, 1),
                                      },
                                     ],
                                     position: (418, 31),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (414, 32),
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "exact",
                                  position: (422, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkOption",
                                 position: (422, 23),
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "type",
                                       position: (423, 17),
                                      },
                                     ],
                                    },
                                    to: PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (423, 24),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       Raw {
                                        content: "bool",
                                        position: (423, 30),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "default",
                                       position: (424, 17),
                                      },
                                     ],
                                    },
                                    to: Variable {
                                     identifier: "true",
                                     position: (424, 27),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "description",
                                       position: (425, 17),
                                      },
                                     ],
                                    },
                                    to: String {
                                     parts: [
                                      Raw {
                                       content: "Whether the <option>from</option> reference needs to match exactly. If set,\na <option>from</option> reference like <literal>nixpkgs</literal> does not\nmatch with a reference like <literal>nixpkgs/nixos-20.03</literal>.\n",
                                       position: (426, 1),
                                      },
                                     ],
                                     position: (425, 31),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (422, 32),
                                 },
                                ],
                               },
                              },
                             ],
                             recursive: false,
                             position: (403, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "config",
                               position: (432, 13),
                              },
                             ],
                            },
                            to: Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "from",
                                  position: (433, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkDefault",
                                 position: (433, 22),
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "type",
                                       position: (433, 34),
                                      },
                                     ],
                                    },
                                    to: String {
                                     parts: [
                                      Raw {
                                       content: "indirect",
                                       position: (433, 42),
                                      },
                                     ],
                                     position: (433, 41),
                                    },
                                   },
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "id",
                                       position: (433, 53),
                                      },
                                     ],
                                    },
                                    to: Variable {
                                     identifier: "name",
                                     position: (433, 58),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (433, 32),
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "to",
                                  position: (434, 15),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: Variable {
                                 identifier: "mkIf",
                                 position: (434, 20),
                                },
                                arguments: [
                                 Parentheses {
                                  expression: BinaryOperation {
                                   operator: NotEqualTo,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "config",
                                      position: (434, 26),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       Raw {
                                        content: "flake",
                                        position: (434, 33),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    Variable {
                                     identifier: "null",
                                     position: (434, 42),
                                    },
                                   ],
                                   position: (434, 39),
                                  },
                                  position: (434, 25),
                                 },
                                 Parentheses {
                                  expression: BinaryOperation {
                                   operator: Update,
                                   operands: [
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "mkDefault",
                                      position: (434, 49),
                                     },
                                     arguments: [
                                      Map {
                                       bindings: [
                                        Binding {
                                         from: AttributePath {
                                          parts: [
                                           Raw {
                                            content: "type",
                                            position: (436, 19),
                                           },
                                          ],
                                         },
                                         to: String {
                                          parts: [
                                           Raw {
                                            content: "path",
                                            position: (436, 27),
                                           },
                                          ],
                                          position: (436, 26),
                                         },
                                        },
                                        Binding {
                                         from: AttributePath {
                                          parts: [
                                           Raw {
                                            content: "path",
                                            position: (437, 19),
                                           },
                                          ],
                                         },
                                         to: PropertyAccess {
                                          expression: Variable {
                                           identifier: "config",
                                           position: (437, 26),
                                          },
                                          attribute_path: AttributePath {
                                           parts: [
                                            Raw {
                                             content: "flake",
                                             position: (437, 33),
                                            },
                                            Raw {
                                             content: "outPath",
                                             position: (437, 39),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                       ],
                                       recursive: false,
                                       position: (435, 17),
                                      },
                                     ],
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "filterAttrs",
                                      position: (438, 22),
                                     },
                                     arguments: [
                                      Parentheses {
                                       expression: Function {
                                        argument: Simple {
                                         identifier: "n",
                                        },
                                        definition: Function {
                                         argument: Simple {
                                          identifier: "_",
                                         },
                                         definition: BinaryOperation {
                                          operator: LogicalOr,
                                          operands: [
                                           BinaryOperation {
                                            operator: LogicalOr,
                                            operands: [
                                             BinaryOperation {
                                              operator: LogicalOr,
                                              operands: [
                                               BinaryOperation {
                                                operator: EqualTo,
                                                operands: [
                                                 Variable {
                                                  identifier: "n",
                                                  position: (439, 24),
                                                 },
                                                 String {
                                                  parts: [
                                                   Raw {
                                                    content: "lastModified",
                                                    position: (439, 30),
                                                   },
                                                  ],
                                                  position: (439, 29),
                                                 },
                                                ],
                                                position: (439, 26),
                                               },
                                               BinaryOperation {
                                                operator: EqualTo,
                                                operands: [
                                                 Variable {
                                                  identifier: "n",
                                                  position: (439, 47),
                                                 },
                                                 String {
                                                  parts: [
                                                   Raw {
                                                    content: "rev",
                                                    position: (439, 53),
                                                   },
                                                  ],
                                                  position: (439, 52),
                                                 },
                                                ],
                                                position: (439, 49),
                                               },
                                              ],
                                              position: (439, 44),
                                             },
                                             BinaryOperation {
                                              operator: EqualTo,
                                              operands: [
                                               Variable {
                                                identifier: "n",
                                                position: (439, 61),
                                               },
                                               String {
                                                parts: [
                                                 Raw {
                                                  content: "revCount",
                                                  position: (439, 67),
                                                 },
                                                ],
                                                position: (439, 66),
                                               },
                                              ],
                                              position: (439, 63),
                                             },
                                            ],
                                            position: (439, 58),
                                           },
                                           BinaryOperation {
                                            operator: EqualTo,
                                            operands: [
                                             Variable {
                                              identifier: "n",
                                              position: (439, 80),
                                             },
                                             String {
                                              parts: [
                                               Raw {
                                                content: "narHash",
                                                position: (439, 86),
                                               },
                                              ],
                                              position: (439, 85),
                                             },
                                            ],
                                            position: (439, 82),
                                           },
                                          ],
                                          position: (439, 77),
                                         },
                                         position: (439, 21),
                                        },
                                        position: (439, 18),
                                       },
                                       position: (439, 17),
                                      },
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "config",
                                        position: (440, 17),
                                       },
                                       attribute_path: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "flake",
                                          position: (440, 24),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     ],
                                    },
                                   ],
                                   position: (438, 19),
                                  },
                                  position: (434, 48),
                                 },
                                ],
                               },
                              },
                             ],
                             recursive: false,
                             position: (432, 22),
                            },
                           },
                          ],
                          recursive: false,
                          position: (402, 11),
                         },
                         position: (401, 11),
                        },
                        position: (393, 11),
                       },
                       position: (392, 47),
                      },
                     ],
                    },
                    position: (392, 30),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (444, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (444, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (445, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "A system-wide flake registry.\n",
                    position: (446, 1),
                   },
                  ],
                  position: (445, 23),
                 },
                },
               ],
               recursive: false,
               position: (391, 27),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraOptions",
               position: (450, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (450, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (451, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (451, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "lines",
                     position: (451, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (452, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [],
                  position: (452, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (453, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "keep-outputs = true\nkeep-derivations = true\n",
                    position: (454, 1),
                   },
                  ],
                  position: (453, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (457, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Additional text appended to <filename>nix.conf</filename>.",
                    position: (457, 24),
                   },
                  ],
                  position: (457, 23),
                 },
                },
               ],
               recursive: false,
               position: (450, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "settings",
               position: (460, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (460, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (461, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (461, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "submodule",
                      position: (461, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "freeformType",
                         position: (462, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "semanticConfType",
                       position: (462, 26),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "options",
                         position: (464, 11),
                        },
                       ],
                      },
                      to: Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "max-jobs",
                            position: (465, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (465, 24),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (466, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (466, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "either",
                                   position: (466, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (466, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "int",
                                    position: (466, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                Parentheses {
                                 expression: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (466, 46),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "enum",
                                      position: (466, 52),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   List {
                                    elements: [
                                     String {
                                      parts: [
                                       Raw {
                                        content: "auto",
                                        position: (466, 60),
                                       },
                                      ],
                                      position: (466, 59),
                                     },
                                    ],
                                    position: (466, 57),
                                   },
                                  ],
                                 },
                                 position: (466, 45),
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (467, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "auto",
                                 position: (467, 26),
                                },
                               ],
                               position: (467, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (468, 15),
                                },
                               ],
                              },
                              to: Int {
                               value: 64,
                               position: (468, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (469, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "This option defines the maximum number of jobs that Nix will try to\nbuild in parallel. The default is auto, which means it will use all\navailable logical cores. It is recommend to set it to the total\nnumber of logical cores in your system (e.g., 16 for two CPUs with 4\ncores each and hyper-threading).\n",
                                 position: (470, 1),
                                },
                               ],
                               position: (469, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (465, 33),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "auto-optimise-store",
                            position: (478, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (478, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (479, 15),
                                },
                               ],
                              },
                              to: PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (479, 22),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "bool",
                                  position: (479, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (480, 15),
                                },
                               ],
                              },
                              to: Variable {
                               identifier: "false",
                               position: (480, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (481, 15),
                                },
                               ],
                              },
                              to: Variable {
                               identifier: "true",
                               position: (481, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (482, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "If set to true, Nix automatically detects files in the store that have\nidentical contents, and replaces them with hard links to a single copy.\nThis saves disk space. If set to false (the default), you can still run\nnix-store --optimise to get rid of duplicate files.\n",
                                 position: (483, 1),
                                },
                               ],
                               position: (482, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (478, 44),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "cores",
                            position: (490, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (490, 21),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (491, 15),
                                },
                               ],
                              },
                              to: PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (491, 22),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "int",
                                  position: (491, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (492, 15),
                                },
                               ],
                              },
                              to: Int {
                               value: 0,
                               position: (492, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (493, 15),
                                },
                               ],
                              },
                              to: Int {
                               value: 64,
                               position: (493, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (494, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "This option defines the maximum number of concurrent tasks during\none build. It affects, e.g., -j option for make.\nThe special value 0 means that the builder should use all\navailable CPU cores in the system. Some builds may become\nnon-deterministic with this option; use with care! Packages will\nonly be affected if enableParallelBuilding is set for them.\n",
                                 position: (495, 1),
                                },
                               ],
                               position: (494, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (490, 30),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "sandbox",
                            position: (504, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (504, 23),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (505, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (505, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "either",
                                   position: (505, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (505, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "bool",
                                    position: (505, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                Parentheses {
                                 expression: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (505, 47),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "enum",
                                      position: (505, 53),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   List {
                                    elements: [
                                     String {
                                      parts: [
                                       Raw {
                                        content: "relaxed",
                                        position: (505, 61),
                                       },
                                      ],
                                      position: (505, 60),
                                     },
                                    ],
                                    position: (505, 58),
                                   },
                                  ],
                                 },
                                 position: (505, 46),
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (506, 15),
                                },
                               ],
                              },
                              to: Variable {
                               identifier: "true",
                               position: (506, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (507, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "If set, Nix will perform builds in a sandboxed environment that it\nwill set up automatically for each build. This prevents impurities\nin builds by disallowing access to dependencies outside of the Nix\nstore by using network and mount namespaces in a chroot environment.\nThis is enabled by default even though it has a possible performance\nimpact due to the initial setup time of a sandbox for each build. It\ndoesn't affect derivation hashes, so changing this option will not\ntrigger a rebuild of packages.\n",
                                 position: (508, 1),
                                },
                               ],
                               position: (507, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (504, 32),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "extra-sandbox-paths",
                            position: (519, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (519, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (520, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (520, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (520, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (520, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (520, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (521, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [],
                               position: (521, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (522, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "/dev",
                                   position: (522, 28),
                                  },
                                 ],
                                 position: (522, 27),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "/proc",
                                   position: (522, 35),
                                  },
                                 ],
                                 position: (522, 34),
                                },
                               ],
                               position: (522, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (523, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "Directories from the host filesystem to be included\nin the sandbox.\n",
                                 position: (524, 1),
                                },
                               ],
                               position: (523, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (519, 44),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "substituters",
                            position: (529, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (529, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (530, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (530, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (530, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (530, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (530, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (531, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "List of binary cache URLs used to obtain pre-built binaries\nof Nix packages.\n\nBy default https://cache.nixos.org/ is added.\n",
                                 position: (532, 1),
                                },
                               ],
                               position: (531, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (529, 37),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "trusted-substituters",
                            position: (539, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (539, 36),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (540, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (540, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (540, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (540, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (540, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (541, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [],
                               position: (541, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (542, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "https://hydra.nixos.org/",
                                   position: (542, 28),
                                  },
                                 ],
                                 position: (542, 27),
                                },
                               ],
                               position: (542, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (543, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "List of binary cache URLs that non-root users can use (in\naddition to those specified using\n<option>nix.settings.substituters</option>) by passing\n<literal>--option binary-caches</literal> to Nix commands.\n",
                                 position: (544, 1),
                                },
                               ],
                               position: (543, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (539, 45),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "require-sigs",
                            position: (551, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (551, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (552, 15),
                                },
                               ],
                              },
                              to: PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (552, 22),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "bool",
                                  position: (552, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (553, 15),
                                },
                               ],
                              },
                              to: Variable {
                               identifier: "true",
                               position: (553, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (554, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "If enabled (the default), Nix will only download binaries from binary caches if\nthey are cryptographically signed with any of the keys listed in\n<option>nix.settings.trusted-public-keys</option>. If disabled, signatures are neither\nrequired nor checked, so it's strongly recommended that you use only\ntrustworthy caches and https to prevent man-in-the-middle attacks.\n",
                                 position: (555, 1),
                                },
                               ],
                               position: (554, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (551, 37),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "trusted-public-keys",
                            position: (563, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (563, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (564, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (564, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (564, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (564, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (564, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (565, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "hydra.nixos.org-1:CNHJZBh9K4tP3EKF6FkkgeVYsS3ohTl+oS0Qa8bezVs=",
                                   position: (565, 28),
                                  },
                                 ],
                                 position: (565, 27),
                                },
                               ],
                               position: (565, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (566, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "List of public keys used to sign binary caches. If\n<option>nix.settings.trusted-public-keys</option> is enabled,\nthen Nix will use a binary from a binary cache if and only\nif it is signed by <emphasis>any</emphasis> of the keys\nlisted here. By default, only the key for\n<uri>cache.nixos.org</uri> is included.\n",
                                 position: (567, 1),
                                },
                               ],
                               position: (566, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (563, 44),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "trusted-users",
                            position: (576, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (576, 29),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (577, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (577, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (577, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (577, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (577, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (578, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "root",
                                   position: (578, 28),
                                  },
                                 ],
                                 position: (578, 27),
                                },
                               ],
                               position: (578, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (579, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "root",
                                   position: (579, 28),
                                  },
                                 ],
                                 position: (579, 27),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "alice",
                                   position: (579, 35),
                                  },
                                 ],
                                 position: (579, 34),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "@wheel",
                                   position: (579, 43),
                                  },
                                 ],
                                 position: (579, 42),
                                },
                               ],
                               position: (579, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (580, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "A list of names of users that have additional rights when\nconnecting to the Nix daemon, such as the ability to specify\nadditional binary caches, or to import unsigned NARs. You\ncan also specify groups by prefixing them with\n<literal>@</literal>; for instance,\n<literal>@wheel</literal> means all users in the wheel\ngroup.\n",
                                 position: (581, 1),
                                },
                               ],
                               position: (580, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (576, 38),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "system-features",
                            position: (591, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (591, 31),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (592, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (592, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (592, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (592, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (592, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (593, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "kvm",
                                   position: (593, 28),
                                  },
                                 ],
                                 position: (593, 27),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "big-parallel",
                                   position: (593, 34),
                                  },
                                 ],
                                 position: (593, 33),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "gccarch-skylake",
                                   position: (593, 49),
                                  },
                                 ],
                                 position: (593, 48),
                                },
                               ],
                               position: (593, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (594, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "The set of features supported by the machine. Derivations\ncan express dependencies on system features through the\n<literal>requiredSystemFeatures</literal> attribute.\n\nBy default, pseudo-features <literal>nixos-test</literal>, <literal>benchmark</literal>,\nand <literal>big-parallel</literal> used in Nixpkgs are set, <literal>kvm</literal>\nis also included in it is avaliable.\n",
                                 position: (595, 1),
                                },
                               ],
                               position: (594, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (591, 40),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "allowed-users",
                            position: (605, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (605, 29),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "type",
                                 position: (606, 15),
                                },
                               ],
                              },
                              to: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (606, 22),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "listOf",
                                   position: (606, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (606, 35),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "str",
                                    position: (606, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "default",
                                 position: (607, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "*",
                                   position: (607, 28),
                                  },
                                 ],
                                 position: (607, 27),
                                },
                               ],
                               position: (607, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "example",
                                 position: (608, 15),
                                },
                               ],
                              },
                              to: List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "@wheel",
                                   position: (608, 28),
                                  },
                                 ],
                                 position: (608, 27),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "@builders",
                                   position: (608, 37),
                                  },
                                 ],
                                 position: (608, 36),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "alice",
                                   position: (608, 49),
                                  },
                                 ],
                                 position: (608, 48),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "bob",
                                   position: (608, 57),
                                  },
                                 ],
                                 position: (608, 56),
                                },
                               ],
                               position: (608, 25),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "description",
                                 position: (609, 15),
                                },
                               ],
                              },
                              to: String {
                               parts: [
                                Raw {
                                 content: "A list of names of users (separated by whitespace) that are\nallowed to connect to the Nix daemon. As with\n<option>nix.settings.trusted-users</option>, you can specify groups by\nprefixing them with <literal>@</literal>. Also, you can\nallow all users by specifying <literal>*</literal>. The\ndefault is <literal>*</literal>. Note that trusted users are\nalways allowed to connect.\n",
                                 position: (610, 1),
                                },
                               ],
                               position: (609, 29),
                              },
                             },
                            ],
                            recursive: false,
                            position: (605, 38),
                           },
                          ],
                         },
                        },
                       ],
                       recursive: false,
                       position: (464, 21),
                      },
                     },
                    ],
                    recursive: false,
                    position: (461, 32),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (621, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (621, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (622, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (622, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  use-sandbox = true;\n  show-trace = true;\n\n  system-features = [ \"big-parallel\" \"kvm\" \"recursive-nix\" ];\n  sandbox-paths = { \"/bin/sh\" = \"",
                      position: (623, 1),
                     },
                     Raw {
                      content: "$",
                      position: (628, 44),
                     },
                     Raw {
                      content: "{pkgs.busybox-sandbox-shell.out}/bin/busybox\"; };\n}\n",
                      position: (628, 47),
                     },
                    ],
                    position: (622, 37),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (631, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Configuration for Nix, see\n<link xlink:href=\"https://nixos.org/manual/nix/stable/#sec-conf-file\"/> or\n<citerefentry>\n  <refentrytitle>nix.conf</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry> for avalaible options.\nThe value declared here will be translated directly to the key-value pairs Nix expects.\n</para>\n<para>\nYou can use <command>nix-instantiate --eval --strict '&lt;nixpkgs/nixos&gt;' -A config.nix.settings</command>\nto view the current value. By default it is empty.\n</para>\n<para>\nNix configurations defined under <option>nix.*</option> will be translated and applied to this\noption. In addition, configuration specified in <option>nix.extraOptions</option> which will be appended\nverbatim to the resulting config file.\n",
                    position: (632, 1),
                   },
                  ],
                  position: (631, 23),
                 },
                },
               ],
               recursive: false,
               position: (460, 27),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (125, 11),
         },
        },
       ],
       recursive: false,
       position: (123, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (656, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (656, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (656, 17),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "enable",
            position: (656, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (657, 5),
             },
             Raw {
              content: "systemPackages",
              position: (657, 17),
             },
            ],
           },
           to: BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               Variable {
                identifier: "nixPackage",
                position: (659, 9),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (660, 9),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "nix-info",
                   position: (660, 14),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (658, 7),
             },
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (662, 10),
              },
              arguments: [
               Parentheses {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (662, 20),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "programs",
                    position: (662, 27),
                   },
                   Raw {
                    content: "bash",
                    position: (662, 36),
                   },
                   Raw {
                    content: "enableCompletion",
                    position: (662, 41),
                   },
                  ],
                 },
                 default: None,
                },
                position: (662, 19),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (662, 59),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "nix-bash-completions",
                   position: (662, 64),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
            position: (662, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (664, 5),
             },
             Raw {
              content: "etc",
              position: (664, 17),
             },
             Expression {
              ast: String {
               parts: [
                Raw {
                 content: "nix/nix.conf",
                 position: (664, 22),
                },
               ],
               position: (664, 21),
              },
             },
             Raw {
              content: "source",
              position: (664, 36),
             },
            ],
           },
           to: Variable {
            identifier: "nixConf",
            position: (664, 45),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (666, 5),
             },
             Raw {
              content: "etc",
              position: (666, 17),
             },
             Expression {
              ast: String {
               parts: [
                Raw {
                 content: "nix/registry.json",
                 position: (666, 22),
                },
               ],
               position: (666, 21),
              },
             },
             Raw {
              content: "text",
              position: (666, 41),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (666, 48),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "toJSON",
                position: (666, 57),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "version",
                   position: (667, 7),
                  },
                 ],
                },
                to: Int {
                 value: 2,
                 position: (667, 17),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "flakes",
                   position: (668, 7),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrsToList",
                  position: (668, 16),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "n",
                    },
                    definition: Function {
                     argument: Simple {
                      identifier: "v",
                     },
                     definition: Map {
                      bindings: [
                       Inherit {
                        from: Some(
                         Variable {
                          identifier: "v",
                          position: (668, 49),
                         },
                        ),
                        attributes: [
                         Raw {
                          content: "from",
                          position: (668, 52),
                         },
                         Raw {
                          content: "to",
                          position: (668, 57),
                         },
                         Raw {
                          content: "exact",
                          position: (668, 60),
                         },
                        ],
                       },
                      ],
                      recursive: false,
                      position: (668, 38),
                     },
                     position: (668, 35),
                    },
                    position: (668, 32),
                   },
                   position: (668, 31),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (668, 70),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "registry",
                      position: (668, 74),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
              recursive: false,
              position: (666, 64),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (673, 5),
             },
             Raw {
              content: "etc",
              position: (673, 17),
             },
             Expression {
              ast: String {
               parts: [
                Raw {
                 content: "nix/machines",
                 position: (673, 22),
                },
               ],
               position: (673, 21),
              },
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (673, 38),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (673, 44),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "buildMachines",
                    position: (673, 48),
                   },
                  ],
                 },
                 default: None,
                },
                List {
                 elements: [],
                 position: (673, 65),
                },
               ],
               position: (673, 62),
              },
              position: (673, 43),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "text",
                   position: (674, 7),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "concatMapStrings",
                  position: (675, 9),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "machine",
                    },
                    definition: BinaryOperation {
                     operator: Addition,
                     operands: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "concatStringsSep",
                         position: (677, 14),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: " ",
                            position: (677, 32),
                           },
                          ],
                          position: (677, 31),
                         },
                         Parentheses {
                          expression: BinaryOperation {
                           operator: Concatenation,
                           operands: [
                            List {
                             elements: [
                              String {
                               parts: [
                                Interpolation {
                                 expression: FunctionApplication {
                                  function: Variable {
                                   identifier: "optionalString",
                                   position: (678, 18),
                                  },
                                  arguments: [
                                   Parentheses {
                                    expression: BinaryOperation {
                                     operator: NotEqualTo,
                                     operands: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "machine",
                                        position: (678, 34),
                                       },
                                       attribute_path: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "sshUser",
                                          position: (678, 42),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      Variable {
                                       identifier: "null",
                                       position: (678, 53),
                                      },
                                     ],
                                     position: (678, 50),
                                    },
                                    position: (678, 33),
                                   },
                                   String {
                                    parts: [
                                     Interpolation {
                                      expression: PropertyAccess {
                                       expression: Variable {
                                        identifier: "machine",
                                        position: (678, 62),
                                       },
                                       attribute_path: AttributePath {
                                        parts: [
                                         Raw {
                                          content: "sshUser",
                                          position: (678, 70),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     },
                                     Raw {
                                      content: "@",
                                      position: (678, 78),
                                     },
                                    ],
                                    position: (678, 59),
                                   },
                                  ],
                                 },
                                },
                                Interpolation {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "machine",
                                   position: (678, 83),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "hostName",
                                     position: (678, 91),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                               ],
                               position: (678, 15),
                              },
                              Parentheses {
                               expression: IfThenElse {
                                predicate: BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "machine",
                                    position: (679, 19),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "system",
                                      position: (679, 27),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (679, 37),
                                  },
                                 ],
                                 position: (679, 34),
                                },
                                then: PropertyAccess {
                                 expression: Variable {
                                  identifier: "machine",
                                  position: (679, 47),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "system",
                                    position: (679, 55),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                else_: IfThenElse {
                                 predicate: BinaryOperation {
                                  operator: NotEqualTo,
                                  operands: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "machine",
                                     position: (679, 70),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "systems",
                                       position: (679, 78),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   List {
                                    elements: [],
                                    position: (679, 89),
                                   },
                                  ],
                                  position: (679, 86),
                                 },
                                 then: FunctionApplication {
                                  function: Variable {
                                   identifier: "concatStringsSep",
                                   position: (679, 98),
                                  },
                                  arguments: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: ",",
                                      position: (679, 116),
                                     },
                                    ],
                                    position: (679, 115),
                                   },
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "machine",
                                     position: (679, 119),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "systems",
                                       position: (679, 127),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                 else_: String {
                                  parts: [
                                   Raw {
                                    content: "-",
                                    position: (679, 141),
                                   },
                                  ],
                                  position: (679, 140),
                                 },
                                 position: (679, 67),
                                },
                                position: (679, 16),
                               },
                               position: (679, 15),
                              },
                              Parentheses {
                               expression: IfThenElse {
                                predicate: BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "machine",
                                    position: (680, 19),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "sshKey",
                                      position: (680, 27),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (680, 37),
                                  },
                                 ],
                                 position: (680, 34),
                                },
                                then: PropertyAccess {
                                 expression: Variable {
                                  identifier: "machine",
                                  position: (680, 47),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "sshKey",
                                    position: (680, 55),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                else_: String {
                                 parts: [
                                  Raw {
                                   content: "-",
                                   position: (680, 68),
                                  },
                                 ],
                                 position: (680, 67),
                                },
                                position: (680, 16),
                               },
                               position: (680, 15),
                              },
                              Parentheses {
                               expression: FunctionApplication {
                                function: Variable {
                                 identifier: "toString",
                                 position: (681, 16),
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "machine",
                                   position: (681, 25),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "maxJobs",
                                     position: (681, 33),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                               position: (681, 15),
                              },
                              Parentheses {
                               expression: FunctionApplication {
                                function: Variable {
                                 identifier: "toString",
                                 position: (682, 16),
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "machine",
                                   position: (682, 25),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "speedFactor",
                                     position: (682, 33),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                               position: (682, 15),
                              },
                              Parentheses {
                               expression: FunctionApplication {
                                function: Variable {
                                 identifier: "concatStringsSep",
                                 position: (683, 16),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: ",",
                                    position: (683, 34),
                                   },
                                  ],
                                  position: (683, 33),
                                 },
                                 Parentheses {
                                  expression: BinaryOperation {
                                   operator: Concatenation,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "machine",
                                      position: (683, 38),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       Raw {
                                        content: "supportedFeatures",
                                        position: (683, 46),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "machine",
                                      position: (683, 67),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       Raw {
                                        content: "mandatoryFeatures",
                                        position: (683, 75),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ],
                                   position: (683, 64),
                                  },
                                  position: (683, 37),
                                 },
                                ],
                               },
                               position: (683, 15),
                              },
                              Parentheses {
                               expression: FunctionApplication {
                                function: Variable {
                                 identifier: "concatStringsSep",
                                 position: (684, 16),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: ",",
                                    position: (684, 34),
                                   },
                                  ],
                                  position: (684, 33),
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "machine",
                                   position: (684, 37),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "mandatoryFeatures",
                                     position: (684, 45),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                               position: (684, 15),
                              },
                             ],
                             position: (677, 36),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "optional",
                              position: (686, 16),
                             },
                             arguments: [
                              Parentheses {
                               expression: FunctionApplication {
                                function: Variable {
                                 identifier: "isNixAtLeast",
                                 position: (686, 26),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "2.4pre",
                                    position: (686, 40),
                                   },
                                  ],
                                  position: (686, 39),
                                 },
                                ],
                               },
                               position: (686, 25),
                              },
                              Parentheses {
                               expression: IfThenElse {
                                predicate: BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "machine",
                                    position: (686, 53),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "publicHostKey",
                                      position: (686, 61),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (686, 78),
                                  },
                                 ],
                                 position: (686, 75),
                                },
                                then: PropertyAccess {
                                 expression: Variable {
                                  identifier: "machine",
                                  position: (686, 88),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "publicHostKey",
                                    position: (686, 96),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                else_: String {
                                 parts: [
                                  Raw {
                                   content: "-",
                                   position: (686, 116),
                                  },
                                 ],
                                 position: (686, 115),
                                },
                                position: (686, 50),
                               },
                               position: (686, 49),
                              },
                             ],
                            },
                           ],
                           position: (686, 13),
                          },
                          position: (677, 35),
                         },
                        ],
                       },
                       position: (677, 13),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "\n",
                         position: (687, 16),
                        },
                       ],
                       position: (687, 15),
                      },
                     ],
                     position: (687, 13),
                    },
                    position: (676, 12),
                   },
                   position: (676, 11),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (689, 11),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "buildMachines",
                      position: (689, 15),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
              recursive: false,
              position: (673, 70),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "assertions",
              position: (692, 5),
             },
            ],
           },
           to: LetIn {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "badMachine",
                 position: (693, 11),
                },
               ],
              },
              to: Function {
               argument: Simple {
                identifier: "m",
               },
               definition: BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (693, 27),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "system",
                       position: (693, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (693, 39),
                   },
                  ],
                  position: (693, 36),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (693, 47),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "systems",
                       position: (693, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [],
                    position: (693, 60),
                   },
                  ],
                  position: (693, 57),
                 },
                ],
                position: (693, 44),
               },
               position: (693, 24),
              },
             },
            ],
            target: List {
             elements: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "assertion",
                    position: (697, 11),
                   },
                  ],
                 },
                 to: UnaryOperation {
                  operator: Not,
                  operand: Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "any",
                     position: (697, 25),
                    },
                    arguments: [
                     Variable {
                      identifier: "badMachine",
                      position: (697, 29),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (697, 40),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "buildMachines",
                         position: (697, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (697, 24),
                  },
                  position: (697, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "message",
                    position: (698, 11),
                   },
                  ],
                 },
                 to: BinaryOperation {
                  operator: Addition,
                  operands: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     String {
                      parts: [
                       Raw {
                        content: "At least one system type (via <varname>system</varname> or\n  <varname>systems</varname>) must be set for every build machine.\n  Invalid machine specifications:\n",
                        position: (699, 1),
                       },
                      ],
                      position: (698, 21),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "      ",
                        position: (702, 17),
                       },
                      ],
                      position: (702, 16),
                     },
                    ],
                    position: (702, 14),
                   },
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "concatStringsSep",
                      position: (703, 12),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\n      ",
                         position: (703, 30),
                        },
                       ],
                       position: (703, 29),
                      },
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "map",
                         position: (704, 14),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "m",
                           },
                           definition: PropertyAccess {
                            expression: Variable {
                             identifier: "m",
                             position: (704, 22),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "hostName",
                               position: (704, 24),
                              },
                             ],
                            },
                            default: None,
                           },
                           position: (704, 19),
                          },
                          position: (704, 18),
                         },
                         Parentheses {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "filter",
                            position: (705, 16),
                           },
                           arguments: [
                            Parentheses {
                             expression: Variable {
                              identifier: "badMachine",
                              position: (705, 24),
                             },
                             position: (705, 23),
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (705, 36),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "buildMachines",
                                position: (705, 40),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                          position: (705, 15),
                         },
                        ],
                       },
                       position: (704, 13),
                      },
                     ],
                    },
                    position: (703, 11),
                   },
                  ],
                  position: (702, 25),
                 },
                },
               ],
               recursive: false,
               position: (696, 9),
              },
             ],
             position: (695, 7),
            },
            position: (693, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (709, 5),
             },
             Raw {
              content: "packages",
              position: (709, 13),
             },
            ],
           },
           to: List {
            elements: [
             Variable {
              identifier: "nixPackage",
              position: (709, 26),
             },
            ],
            position: (709, 24),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (715, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (715, 13),
             },
             Raw {
              content: "rules",
              position: (715, 22),
             },
            ],
           },
           to: List {
            elements: [
             String {
              parts: [
               Raw {
                content: "d /nix/var/nix/daemon-socket 0755 root root - -",
                position: (716, 8),
               },
              ],
              position: (716, 7),
             },
            ],
            position: (715, 30),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (719, 5),
             },
             Raw {
              content: "sockets",
              position: (719, 13),
             },
             Raw {
              content: "nix-daemon",
              position: (719, 21),
             },
             Raw {
              content: "wantedBy",
              position: (719, 32),
             },
            ],
           },
           to: List {
            elements: [
             String {
              parts: [
               Raw {
                content: "sockets.target",
                position: (719, 46),
               },
              ],
              position: (719, 45),
             },
            ],
            position: (719, 43),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (721, 5),
             },
             Raw {
              content: "services",
              position: (721, 13),
             },
             Raw {
              content: "nix-daemon",
              position: (721, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (723, 9),
                },
               ],
              },
              to: BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  Variable {
                   identifier: "nixPackage",
                   position: (723, 18),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (723, 29),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "util-linux",
                      position: (723, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (723, 45),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "programs",
                      position: (723, 52),
                     },
                     Raw {
                      content: "ssh",
                      position: (723, 61),
                     },
                     Raw {
                      content: "package",
                      position: (723, 65),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (723, 16),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionals",
                  position: (724, 14),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (724, 24),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "distributedBuilds",
                      position: (724, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (724, 48),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "gzip",
                        position: (724, 53),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (724, 46),
                  },
                 ],
                },
               ],
               position: (724, 11),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "environment",
                 position: (726, 9),
                },
               ],
              },
              to: BinaryOperation {
               operator: Update,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (726, 23),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "envVars",
                    position: (726, 27),
                   },
                  ],
                 },
                 default: None,
                },
                BinaryOperation {
                 operator: Update,
                 operands: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "CURL_CA_BUNDLE",
                        position: (727, 16),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "/etc/ssl/certs/ca-certificates.crt",
                        position: (727, 34),
                       },
                      ],
                      position: (727, 33),
                     },
                    },
                   ],
                   recursive: false,
                   position: (727, 14),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (728, 14),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "networking",
                      position: (728, 21),
                     },
                     Raw {
                      content: "proxy",
                      position: (728, 32),
                     },
                     Raw {
                      content: "envVars",
                      position: (728, 38),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (728, 11),
                },
               ],
               position: (727, 11),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "unitConfig",
                 position: (730, 9),
                },
                Raw {
                 content: "RequiresMountsFor",
                 position: (730, 20),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "/nix/store",
                 position: (730, 41),
                },
               ],
               position: (730, 40),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (732, 9),
                },
               ],
              },
              to: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "CPUSchedulingPolicy",
                    position: (734, 13),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (734, 35),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "daemonCPUSchedPolicy",
                     position: (734, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "IOSchedulingClass",
                    position: (735, 13),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (735, 33),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "daemonIOSchedClass",
                     position: (735, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "IOSchedulingPriority",
                    position: (736, 13),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (736, 36),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "daemonIOSchedPriority",
                     position: (736, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "LimitNOFILE",
                    position: (737, 13),
                   },
                  ],
                 },
                 to: Int {
                  value: 4096,
                  position: (737, 27),
                 },
                },
               ],
               recursive: false,
               position: (733, 11),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "restartTriggers",
                 position: (740, 9),
                },
               ],
              },
              to: List {
               elements: [
                Variable {
                 identifier: "nixConf",
                 position: (740, 29),
                },
               ],
               position: (740, 27),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "stopIfChanged",
                 position: (773, 9),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (773, 25),
              },
             },
            ],
            recursive: false,
            position: (722, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (778, 5),
             },
             Raw {
              content: "sessionVariables",
              position: (778, 17),
             },
            ],
           },
           to: BinaryOperation {
            operator: Update,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (778, 36),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "envVars",
                 position: (778, 40),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "NIX_PATH",
                   position: (778, 53),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (778, 64),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "nixPath",
                    position: (778, 68),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
              recursive: false,
              position: (778, 51),
             },
            ],
            position: (778, 48),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (780, 5),
             },
             Raw {
              content: "extraInit",
              position: (780, 17),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "if [ -e \"$HOME/.nix-defexpr/channels\" ]; then\n  export NIX_PATH=\"$HOME/.nix-defexpr/channels",
              position: (782, 1),
             },
             Raw {
              content: "$",
              position: (783, 55),
             },
             Raw {
              content: "{NIX_PATH:+:$NIX_PATH}\"\nfi\n",
              position: (783, 58),
             },
            ],
            position: (781, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "nix",
              position: (787, 5),
             },
             Raw {
              content: "nrBuildUsers",
              position: (787, 9),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (787, 24),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "max",
                position: (787, 35),
               },
               arguments: [
                Int {
                 value: 32,
                 position: (787, 39),
                },
                Parentheses {
                 expression: IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (787, 46),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "settings",
                        position: (787, 50),
                       },
                       Raw {
                        content: "max-jobs",
                        position: (787, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "auto",
                       position: (787, 72),
                      },
                     ],
                     position: (787, 71),
                    },
                   ],
                   position: (787, 68),
                  },
                  then: Int {
                   value: 0,
                   position: (787, 83),
                  },
                  else_: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (787, 90),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "settings",
                      position: (787, 94),
                     },
                     Raw {
                      content: "max-jobs",
                      position: (787, 103),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (787, 43),
                 },
                 position: (787, 42),
                },
               ],
              },
              position: (787, 34),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "users",
              position: (789, 5),
             },
             Raw {
              content: "users",
              position: (789, 11),
             },
            ],
           },
           to: Variable {
            identifier: "nixbldUsers",
            position: (789, 19),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (791, 5),
             },
             Raw {
              content: "xserver",
              position: (791, 14),
             },
             Raw {
              content: "displayManager",
              position: (791, 22),
             },
             Raw {
              content: "hiddenUsers",
              position: (791, 37),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "attrNames",
             position: (791, 51),
            },
            arguments: [
             Variable {
              identifier: "nixbldUsers",
              position: (791, 61),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "system",
              position: (793, 5),
             },
             Raw {
              content: "activationScripts",
              position: (793, 12),
             },
             Raw {
              content: "nix",
              position: (793, 30),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "stringAfter",
             position: (793, 36),
            },
            arguments: [
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "etc",
                  position: (793, 51),
                 },
                ],
                position: (793, 50),
               },
               String {
                parts: [
                 Raw {
                  content: "users",
                  position: (793, 57),
                 },
                ],
                position: (793, 56),
               },
              ],
              position: (793, 48),
             },
             String {
              parts: [
               Raw {
                content: "install -m 0755 -d /nix/var/nix/{gcroots,profiles}/per-user\n\n# Subscribe the root user to the NixOS channel by default.\nif [ ! -e \"/root/.nix-channels\" ]; then\n    echo \"",
                position: (795, 1),
               },
               Interpolation {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (799, 21),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "system",
                    position: (799, 28),
                   },
                   Raw {
                    content: "defaultChannel",
                    position: (799, 35),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " nixos\" > \"/root/.nix-channels\"\nfi\n",
                position: (799, 50),
               },
              ],
              position: (794, 7),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "nix",
              position: (804, 5),
             },
             Raw {
              content: "settings",
              position: (804, 9),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (804, 20),
            },
            arguments: [
             List {
              elements: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "trusted-public-keys",
                     position: (806, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=",
                       position: (806, 34),
                      },
                     ],
                     position: (806, 33),
                    },
                   ],
                   position: (806, 31),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "substituters",
                     position: (807, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "mkAfter",
                    position: (807, 24),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "https://cache.nixos.org/",
                         position: (807, 35),
                        },
                       ],
                       position: (807, 34),
                      },
                     ],
                     position: (807, 32),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "system-features",
                     position: (809, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (809, 27),
                   },
                   arguments: [
                    Parentheses {
                     expression: BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "nixos-test",
                            position: (810, 14),
                           },
                          ],
                          position: (810, 13),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "benchmark",
                            position: (810, 27),
                           },
                          ],
                          position: (810, 26),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "big-parallel",
                            position: (810, 39),
                           },
                          ],
                          position: (810, 38),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "kvm",
                            position: (810, 54),
                           },
                          ],
                          position: (810, 53),
                         },
                        ],
                        position: (810, 11),
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (811, 11),
                        },
                        arguments: [
                         Parentheses {
                          expression: HasProperty {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (811, 22),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "hostPlatform",
                               position: (811, 27),
                              },
                             ],
                            },
                            default: None,
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "gcc",
                              position: (811, 42),
                             },
                             Raw {
                              content: "arch",
                              position: (811, 46),
                             },
                            ],
                           },
                           position: (811, 40),
                          },
                          position: (811, 21),
                         },
                         Parentheses {
                          expression: BinaryOperation {
                           operator: Concatenation,
                           operands: [
                            List {
                             elements: [
                              String {
                               parts: [
                                Raw {
                                 content: "gccarch-",
                                 position: (813, 16),
                                },
                                Interpolation {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (813, 26),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "hostPlatform",
                                     position: (813, 31),
                                    },
                                    Raw {
                                     content: "gcc",
                                     position: (813, 44),
                                    },
                                    Raw {
                                     content: "arch",
                                     position: (813, 48),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                               ],
                               position: (813, 15),
                              },
                             ],
                             position: (813, 13),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "map",
                              position: (814, 13),
                             },
                             arguments: [
                              Parentheses {
                               expression: Function {
                                argument: Simple {
                                 identifier: "x",
                                },
                                definition: String {
                                 parts: [
                                  Raw {
                                   content: "gccarch-",
                                   position: (814, 22),
                                  },
                                  Interpolation {
                                   expression: Variable {
                                    identifier: "x",
                                    position: (814, 32),
                                   },
                                  },
                                 ],
                                 position: (814, 21),
                                },
                                position: (814, 18),
                               },
                               position: (814, 17),
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "systems",
                                position: (814, 37),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "architectures",
                                  position: (814, 45),
                                 },
                                 Raw {
                                  content: "inferiors",
                                  position: (814, 59),
                                 },
                                 Interpolation {
                                  expression: PropertyAccess {
                                   expression: Variable {
                                    identifier: "pkgs",
                                    position: (814, 71),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "hostPlatform",
                                      position: (814, 76),
                                     },
                                     Raw {
                                      content: "gcc",
                                      position: (814, 89),
                                     },
                                     Raw {
                                      content: "arch",
                                      position: (814, 93),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           ],
                           position: (813, 57),
                          },
                          position: (811, 52),
                         },
                        ],
                       },
                      ],
                      position: (810, 61),
                     },
                     position: (809, 37),
                    },
                   ],
                  },
                 },
                ],
                recursive: false,
                position: (805, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (819, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: UnaryOperation {
                    operator: Not,
                    operand: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (819, 15),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "distributedBuilds",
                        position: (819, 19),
                       },
                      ],
                     },
                     default: None,
                    },
                    position: (819, 14),
                   },
                   position: (819, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "builders",
                        position: (819, 40),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "null",
                      position: (819, 51),
                     },
                    },
                   ],
                   recursive: false,
                   position: (819, 38),
                  },
                 ],
                },
                position: (819, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (821, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "isNixAtLeast",
                     position: (821, 14),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "2.3pre",
                        position: (821, 28),
                       },
                      ],
                      position: (821, 27),
                     },
                    ],
                   },
                   position: (821, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "sandbox-fallback",
                        position: (821, 39),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "false",
                      position: (821, 58),
                     },
                    },
                   ],
                   recursive: false,
                   position: (821, 37),
                  },
                 ],
                },
                position: (821, 7),
               },
              ],
              position: (804, 28),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (656, 28),
        },
       ],
      },
     },
    ],
    recursive: false,
    position: (113, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}