---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "slurm",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (8, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (8, 17),
        },
        Raw {
         content: "slurm",
         position: (8, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "defaultUser",
        position: (11, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "slurm",
        position: (11, 18),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (13, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeTextDir",
          position: (13, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "slurm.conf",
          position: (13, 35),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "ClusterName=",
          position: (15, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (15, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "clusterName",
              position: (15, 25),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nStateSaveLocation=",
          position: (15, 37),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (16, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "stateSaveLocation",
              position: (16, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nSlurmUser=",
          position: (16, 49),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (17, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "user",
              position: (17, 23),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (17, 28),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (18, 9),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (18, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "controlMachine",
                  position: (18, 29),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (18, 47),
              },
             ],
             position: (18, 44),
            },
            String {
             parts: [
              Raw {
               content: "controlMachine=",
               position: (18, 54),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (18, 71),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "controlMachine",
                   position: (18, 75),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (18, 92),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (19, 9),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (19, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "controlAddr",
                  position: (19, 29),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (19, 44),
              },
             ],
             position: (19, 41),
            },
            String {
             parts: [
              Raw {
               content: "controlAddr=",
               position: (19, 51),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (19, 65),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "controlAddr",
                   position: (19, 69),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (19, 83),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (20, 9),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (20, 19),
             },
             arguments: [
              Function {
               argument: Some(
                "x",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: String {
                parts: [
                 Raw {
                  content: "NodeName=",
                  position: (20, 28),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "x",
                   position: (20, 39),
                  },
                 },
                 Raw {
                  content: "\n",
                  position: (20, 41),
                 },
                ],
               },
               position: (20, 24),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (20, 46),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "nodeName",
                  position: (20, 50),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (20, 60),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (21, 9),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (21, 19),
             },
             arguments: [
              Function {
               argument: Some(
                "x",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: String {
                parts: [
                 Raw {
                  content: "PartitionName=",
                  position: (21, 28),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "x",
                   position: (21, 44),
                  },
                 },
                 Raw {
                  content: "\n",
                  position: (21, 46),
                 },
                ],
               },
               position: (21, 24),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (21, 51),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "partitionName",
                  position: (21, 55),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nPlugStackConfig=",
          position: (21, 70),
         },
         Expression {
          expression: Variable {
           identifier: "plugStackConfig",
           position: (22, 25),
          },
         },
         Raw {
          content: "/plugstack.conf\nProctrackType=",
          position: (22, 41),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (23, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "procTrackType",
              position: (23, 27),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (23, 41),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (24, 9),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraConfig",
              position: (24, 13),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (24, 25),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "plugStackConfig",
        position: (27, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (27, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeTextDir",
          position: (27, 26),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "plugstack.conf",
          position: (27, 40),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "",
          position: (29, 1),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (29, 9),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (29, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enableSrunX11",
                position: (29, 28),
               },
              ],
             },
             default: None,
            },
            String {
             parts: [
              Raw {
               content: "optional ",
               position: (29, 43),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (29, 54),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "slurm-spank-x11",
                   position: (29, 59),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/lib/x11.so",
               position: (29, 75),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (29, 88),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (30, 9),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraPlugstackConfig",
              position: (30, 13),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (30, 34),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cgroupConfig",
        position: (33, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (33, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeTextDir",
          position: (33, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "cgroup.conf",
          position: (33, 37),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "",
          position: (35, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (35, 8),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraCgroupConfig",
              position: (35, 12),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (35, 30),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "slurmdbdConf",
        position: (38, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (38, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (38, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "slurmdbd.conf",
          position: (38, 34),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "DbdHost=",
          position: (40, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (40, 16),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dbdserver",
              position: (40, 20),
             },
             Raw {
              content: "dbdHost",
              position: (40, 30),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nSlurmUser=",
          position: (40, 38),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (41, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "user",
              position: (41, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nStorageType=accounting_storage/mysql\nStorageUser=",
          position: (41, 27),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (43, 20),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dbdserver",
              position: (43, 24),
             },
             Raw {
              content: "storageUser",
              position: (43, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (43, 46),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (44, 8),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dbdserver",
              position: (44, 12),
             },
             Raw {
              content: "extraConfig",
              position: (44, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (44, 34),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "etcSlurm",
        position: (49, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (49, 14),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "symlinkJoin",
          position: (49, 19),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (50, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "etc-slurm",
             position: (50, 13),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "paths",
             position: (51, 5),
            },
           ],
          },
          BinaryOperation {
           operator: Concatenation,
           operands: [
            List {
             elements: [
              Variable {
               identifier: "configFile",
               position: (51, 15),
              },
              Variable {
               identifier: "cgroupConfig",
               position: (51, 26),
              },
              Variable {
               identifier: "plugStackConfig",
               position: (51, 39),
              },
             ],
             position: (51, 13),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (51, 60),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "extraConfigPaths",
                position: (51, 64),
               },
              ],
             },
             default: None,
            },
           ],
           position: (51, 57),
          },
         ),
        ],
        recursive: false,
        position: (49, 31),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (59, 3),
        },
        Raw {
         content: "maintainers",
         position: (59, 8),
        },
       ],
      },
      List {
       elements: [
        PropertyAccess {
         expression: Variable {
          identifier: "maintainers",
          position: (59, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "markuskowa",
            position: (59, 36),
           },
          ],
         },
         default: None,
        },
       ],
       position: (59, 22),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (61, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (63, 5),
           },
           Raw {
            content: "slurm",
            position: (63, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "server",
               position: (65, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (66, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (66, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (67, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (67, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (67, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (68, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (68, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (69, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to enable the slurm control daemon.\nNote that the standard authentication method is \"munge\".\nThe \"munge\" service needs to be provided with a password file in order for\nslurm to work properly (see <literal>services.munge.password</literal>).\n",
                       position: (70, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (66, 27),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (65, 16),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dbdserver",
               position: (78, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (79, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkEnableOption",
                 position: (79, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "SlurmDBD service",
                    position: (79, 34),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "dbdHost",
                  position: (81, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (81, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (82, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (82, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (82, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (83, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (83, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "networking",
                        position: (83, 28),
                       },
                       Raw {
                        content: "hostName",
                        position: (83, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (84, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (84, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "config.networking.hostName",
                         position: (84, 44),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (85, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Hostname of the machine where <literal>slurmdbd</literal>\nis running (i.e. name returned by <literal>hostname -s</literal>).\n",
                       position: (86, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (81, 28),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "storageUser",
                  position: (91, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (91, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (92, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (92, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (92, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (93, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (93, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (93, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (94, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (94, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "config.",
                         position: (94, 44),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (94, 53),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "user",
                             position: (94, 57),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (95, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database user name.\n",
                       position: (96, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (91, 32),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "storagePassFile",
                  position: (100, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (100, 27),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (101, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (101, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "nullOr",
                       position: (101, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (101, 37),
                       },
                      ],
                     },
                     position: (101, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (102, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (102, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (103, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to file with database password. The content of this will be used to\ncreate the password for the <literal>StoragePass</literal> option.\n",
                       position: (104, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (100, 36),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "extraConfig",
                  position: (109, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (109, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (110, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (110, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "lines",
                        position: (110, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (111, 11),
                      },
                     ],
                    },
                    String {
                     parts: [],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (112, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Extra configuration for <literal>slurmdbd.conf</literal> See also:\n<citerefentry><refentrytitle>slurmdbd.conf</refentrytitle>\n<manvolnum>8</manvolnum></citerefentry>.\n",
                       position: (113, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (109, 32),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (78, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "client",
               position: (120, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (121, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkEnableOption",
                 position: (121, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "slurm client daemon",
                    position: (121, 34),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (120, 16),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableStools",
               position: (124, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (124, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (125, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (125, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (125, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (126, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (126, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (127, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to provide a slurm.conf file.\nEnable this option if you do not run a slurm daemon on this host\n(i.e. <literal>server.enable</literal> and <literal>client.enable</literal> are <literal>false</literal>)\nbut you still want to run slurm commands from this host.\n",
                    position: (128, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (124, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (135, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (135, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (136, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (136, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (136, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (137, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (137, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "slurm",
                      position: (137, 24),
                     },
                     Raw {
                      content: "override",
                      position: (137, 30),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "enableX11",
                         position: (137, 41),
                        },
                       ],
                      },
                      UnaryOperation {
                       operator: Not,
                       operand: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (137, 55),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enableSrunX11",
                           position: (137, 59),
                          },
                         ],
                        },
                        default: None,
                       },
                       position: (137, 53),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (137, 39),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (138, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (138, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.slurm",
                      position: (138, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (139, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (139, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.slurm-full",
                      position: (139, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (140, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The package to use for slurm binaries.\n",
                    position: (141, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (135, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "controlMachine",
               position: (145, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (145, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (146, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (146, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (146, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (146, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (147, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (147, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (148, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (148, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (149, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The short hostname of the machine where SLURM control functions are\nexecuted (i.e. the name returned by the command \"hostname -s\", use \"tux001\"\nrather than \"tux001.my.com\").\n",
                    position: (150, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (145, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "controlAddr",
               position: (156, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (156, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (157, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (157, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (157, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (157, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (157, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (158, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (158, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "controlMachine",
                     position: (158, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (159, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (159, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "config.",
                      position: (159, 42),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (159, 51),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "controlMachine",
                          position: (159, 55),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (160, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (160, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (161, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Name that ControlMachine should be referred to in establishing a\ncommunications path.\n",
                    position: (162, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (156, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "clusterName",
               position: (167, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (167, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (168, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (168, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (168, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (169, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "default",
                    position: (169, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (170, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "myCluster",
                    position: (170, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (171, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Necessary to distinguish accounting records in a multi-cluster environment.\n",
                    position: (172, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (167, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nodeName",
               position: (176, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (176, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (177, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (177, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (177, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (177, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (177, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (178, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (178, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (179, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (179, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ \"linux[1-32] CPUs=1 State=UNKNOWN\" ];",
                      position: (179, 39),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (180, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Name that SLURM uses to refer to a node (or base partition for BlueGene\nsystems). Typically this would be the string that \"/bin/hostname -s\"\nreturns. Note that now you have to write node's parameters after the name.\n",
                    position: (181, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (176, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "partitionName",
               position: (187, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (187, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (188, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (188, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (188, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (188, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (188, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (189, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (189, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (190, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (190, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ \"debug Nodes=linux[1-32] Default=YES MaxTime=INFINITE State=UP\" ];",
                      position: (190, 39),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (191, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Name by which the partition may be referenced. Note that now you have\nto write the partition's parameters after the name.\n",
                    position: (192, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (187, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableSrunX11",
               position: (197, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (197, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (198, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (198, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (199, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (199, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (199, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (200, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If enabled srun will accept the option \"--x11\" to allow for X11 forwarding\nfrom within an interactive session or a batch job. This activates the\nslurm-spank-x11 module. Note that this option also enables\n<option>services.openssh.forwardX11</option> on the client.\n\nThis option requires slurm to be compiled without native X11 support.\nThe default behavior is to re-compile the slurm package with native X11\nsupport disabled if this option is set to true.\n\nTo use the native X11 support add <literal>PrologFlags=X11</literal> in <option>extraConfig</option>.\nNote that this method will only work RSA SSH host keys.\n",
                    position: (201, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (197, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "procTrackType",
               position: (215, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (215, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (216, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (216, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (216, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (217, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "proctrack/linuxproc",
                    position: (217, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (218, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Plugin to be used for process tracking on a job step basis.\nThe slurmd daemon uses this mechanism to identify all processes\nwhich are children of processes it spawns for a user job step.\n",
                    position: (219, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (215, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "stateSaveLocation",
               position: (225, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (225, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (226, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (226, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (226, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (227, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/spool/slurmctld",
                    position: (227, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (228, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Directory into which the Slurm controller, slurmctld, saves its state.\n",
                    position: (229, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (225, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (233, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (233, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (234, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (234, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (234, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (235, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "defaultUser",
                  position: (235, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (236, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set this option when you want to run the slurmctld daemon\nas something else than the default slurm user \"slurm\".\nNote that the UID of this user needs to be the same\non all nodes.\n",
                    position: (237, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (233, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (244, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (244, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (245, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (246, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (246, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (246, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (247, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration options that will be added verbatim at\nthe end of the slurm configuration file.\n",
                    position: (248, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (244, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraPlugstackConfig",
               position: (253, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (253, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (254, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (255, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (255, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (255, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (256, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration that will be added to the end of <literal>plugstack.conf</literal>.\n",
                    position: (257, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (253, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraCgroupConfig",
               position: (261, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (261, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (262, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (263, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (263, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (263, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (264, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration for <literal>cgroup.conf</literal>. This file is\nused when <literal>procTrackType=proctrack/cgroup</literal>.\n",
                    position: (265, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (261, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfigPaths",
               position: (270, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (270, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (271, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (271, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (271, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (271, 35),
                    },
                   ],
                  },
                  position: (271, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (272, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (272, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (273, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Slurm expects config files for plugins in the same path\nas <literal>slurm.conf</literal>. Add extra nix store\npaths that should be merged into same directory as\n<literal>slurm.conf</literal>.\n",
                    position: (274, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (270, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "etcSlurm",
               position: (281, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (281, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (282, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (282, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (282, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (283, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (283, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (284, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "etcSlurm",
                  position: (284, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (285, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalDocBook",
                   position: (285, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Directory created from generated config files and\n<literal>config.",
                      position: (286, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (287, 29),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "extraConfigPaths",
                          position: (287, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "</literal>.\n",
                      position: (287, 50),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (289, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to directory with slurm config files. This option is set by default from the\nSlurm module and is meant to make the Slurm config file available to other modules.\n",
                    position: (290, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (281, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (63, 22),
         },
        ),
       ],
       recursive: false,
       position: (61, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (299, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (300, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (300, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "slurm",
               position: (300, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "dbdserver",
               position: (300, 50),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "storagePass",
               position: (300, 62),
              },
             ],
            },
           ],
           position: (300, 28),
          },
          String {
           parts: [
            Raw {
             content: "This option has been removed so that the database password is not exposed via the nix store.\nUse services.slurm.dbdserver.storagePassFile to provide the database password.\n",
             position: (301, 1),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (304, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (304, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "slurm",
               position: (304, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "dbdserver",
               position: (304, 50),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "configFile",
               position: (304, 62),
              },
             ],
            },
           ],
           position: (304, 28),
          },
          String {
           parts: [
            Raw {
             content: "This option has been removed. Use services.slurm.dbdserver.storagePassFile\nand services.slurm.dbdserver.extraConfig instead.\n",
             position: (305, 1),
            },
           ],
          },
         ],
        },
       ],
       position: (299, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (312, 3),
        },
       ],
      },
      LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "wrappedSlurm",
            position: (314, 7),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (314, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "stdenv",
              position: (314, 27),
             },
             Raw {
              content: "mkDerivation",
              position: (314, 34),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "name",
                 position: (315, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "wrappedSlurm",
                 position: (315, 17),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "builder",
                 position: (317, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (317, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "writeText",
                   position: (317, 24),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "builder.sh",
                   position: (317, 35),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "source $stdenv/setup\nmkdir -p $out/bin\nfind  ",
                   position: (318, 1),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "getBin",
                     position: (320, 19),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (320, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (320, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "/bin -type f -executable | while read EXE\ndo\n  exename=\"$(basename $EXE)\"\n  wrappername=\"$out/bin/$exename\"\n  cat > \"$wrappername\" <<EOT\n#!/bin/sh\nif [ -z \"$SLURM_CONF\" ]\nthen\n  SLURM_CONF=\"",
                   position: (320, 38),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (328, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "etcSlurm",
                       position: (328, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/slurm.conf\" \"$EXE\" \"\\$@\"\nelse\n  \"$EXE\" \"\\$0\"\nfi\nEOT\n  chmod +x \"$wrappername\"\ndone\n\nmkdir -p $out/share\nln -s ",
                   position: (328, 40),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "getBin",
                     position: (337, 19),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (337, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (337, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "/share/man $out/share/man\n",
                   position: (337, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (314, 47),
           },
          ],
         },
        ),
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "mkIf",
         position: (341, 6),
        },
        arguments: [
         BinaryOperation {
          operator: LogicalOr,
          operands: [
           BinaryOperation {
            operator: LogicalOr,
            operands: [
             BinaryOperation {
              operator: LogicalOr,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (341, 13),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "enableStools",
                   position: (341, 17),
                  },
                 ],
                },
                default: None,
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (342, 13),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "client",
                   position: (342, 17),
                  },
                  Raw {
                   content: "enable",
                   position: (342, 24),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (341, 30),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (343, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "server",
                 position: (343, 17),
                },
                Raw {
                 content: "enable",
                 position: (343, 24),
                },
               ],
              },
              default: None,
             },
            ],
            position: (342, 31),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (344, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "dbdserver",
               position: (344, 17),
              },
              Raw {
               content: "enable",
               position: (344, 27),
              },
             ],
            },
            default: None,
           },
          ],
          position: (343, 31),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "environment",
               position: (346, 5),
              },
              Raw {
               content: "systemPackages",
               position: (346, 17),
              },
             ],
            },
            List {
             elements: [
              Variable {
               identifier: "wrappedSlurm",
               position: (346, 36),
              },
             ],
             position: (346, 34),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "services",
               position: (348, 5),
              },
              Raw {
               content: "munge",
               position: (348, 14),
              },
              Raw {
               content: "enable",
               position: (348, 20),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkDefault",
              position: (348, 29),
             },
             arguments: [
              Variable {
               identifier: "true",
               position: (348, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (351, 5),
              },
              Raw {
               content: "users",
               position: (351, 11),
              },
              Raw {
               content: "slurm",
               position: (351, 17),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (351, 25),
             },
             arguments: [
              BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (351, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (351, 35),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "defaultUser",
                 position: (351, 43),
                },
               ],
               position: (351, 40),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (352, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "defaultUser",
                  position: (352, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (353, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "slurm",
                    position: (353, 16),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "uid",
                    position: (354, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (354, 13),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ids",
                     position: (354, 20),
                    },
                    Raw {
                     content: "uids",
                     position: (354, 24),
                    },
                    Raw {
                     content: "slurm",
                     position: (354, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (351, 56),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (357, 5),
              },
              Raw {
               content: "groups",
               position: (357, 11),
              },
              Raw {
               content: "slurm",
               position: (357, 18),
              },
              Raw {
               content: "gid",
               position: (357, 24),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (357, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "ids",
                position: (357, 37),
               },
               Raw {
                content: "uids",
                position: (357, 41),
               },
               Raw {
                content: "slurm",
                position: (357, 46),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (359, 5),
              },
              Raw {
               content: "services",
               position: (359, 13),
              },
              Raw {
               content: "slurmd",
               position: (359, 22),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (359, 31),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (359, 37),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "client",
                  position: (359, 41),
                 },
                 Raw {
                  content: "enable",
                  position: (359, 48),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (360, 7),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (360, 19),
                  },
                  target: BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    List {
                     elements: [
                      Variable {
                       identifier: "wrappedSlurm",
                       position: (360, 27),
                      },
                      Variable {
                       identifier: "coreutils",
                       position: (360, 40),
                      },
                     ],
                     position: (360, 25),
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "lib",
                       position: (361, 12),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "optional",
                         position: (361, 16),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (361, 25),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enableSrunX11",
                          position: (361, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "slurm-spank-x11",
                       position: (361, 43),
                      },
                     ],
                    },
                   ],
                   position: (361, 9),
                  },
                  position: (360, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (363, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "multi-user.target",
                      position: (363, 21),
                     },
                    ],
                   },
                  ],
                  position: (363, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (364, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "systemd-tmpfiles-clean.service",
                      position: (364, 18),
                     },
                    ],
                   },
                  ],
                  position: (364, 15),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "requires",
                    position: (365, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "network.target",
                      position: (365, 21),
                     },
                    ],
                   },
                  ],
                  position: (365, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (367, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Type",
                       position: (368, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "forking",
                       position: (368, 17),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "KillMode",
                       position: (369, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "process",
                       position: (369, 21),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (370, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "wrappedSlurm",
                        position: (370, 24),
                       },
                      },
                      Raw {
                       content: "/bin/slurmd",
                       position: (370, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PIDFile",
                       position: (371, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/slurmd.pid",
                       position: (371, 20),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecReload",
                       position: (372, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (372, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "coreutils",
                           position: (372, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/bin/kill -HUP $MAINPID",
                       position: (372, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "LimitMEMLOCK",
                       position: (373, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "infinity",
                       position: (373, 25),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (367, 23),
                 },
                ),
               ],
               recursive: false,
               position: (359, 56),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (377, 5),
              },
              Raw {
               content: "tmpfiles",
               position: (377, 13),
              },
              Raw {
               content: "rules",
               position: (377, 22),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (377, 30),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (377, 35),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "client",
                  position: (377, 39),
                 },
                 Raw {
                  content: "enable",
                  position: (377, 46),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "d /var/spool/slurmd 755 root root -",
                   position: (378, 8),
                  },
                 ],
                },
               ],
               position: (377, 53),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "services",
               position: (381, 5),
              },
              Raw {
               content: "openssh",
               position: (381, 14),
              },
              Raw {
               content: "forwardX11",
               position: (381, 22),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (381, 35),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (381, 40),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "client",
                  position: (381, 44),
                 },
                 Raw {
                  content: "enable",
                  position: (381, 51),
                 },
                ],
               },
               default: None,
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (381, 59),
               },
               arguments: [
                Variable {
                 identifier: "true",
                 position: (381, 69),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (383, 5),
              },
              Raw {
               content: "services",
               position: (383, 13),
              },
              Raw {
               content: "slurmctld",
               position: (383, 22),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (383, 34),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (383, 40),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "server",
                  position: (383, 44),
                 },
                 Raw {
                  content: "enable",
                  position: (383, 51),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (384, 7),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (384, 19),
                  },
                  target: BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    List {
                     elements: [
                      Variable {
                       identifier: "wrappedSlurm",
                       position: (384, 27),
                      },
                      Variable {
                       identifier: "munge",
                       position: (384, 40),
                      },
                      Variable {
                       identifier: "coreutils",
                       position: (384, 46),
                      },
                     ],
                     position: (384, 25),
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "lib",
                       position: (385, 12),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "optional",
                         position: (385, 16),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (385, 25),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enableSrunX11",
                          position: (385, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "slurm-spank-x11",
                       position: (385, 43),
                      },
                     ],
                    },
                   ],
                   position: (385, 9),
                  },
                  position: (384, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (387, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "multi-user.target",
                      position: (387, 21),
                     },
                    ],
                   },
                  ],
                  position: (387, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (388, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "network.target",
                      position: (388, 18),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "munged.service",
                      position: (388, 35),
                     },
                    ],
                   },
                  ],
                  position: (388, 15),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "requires",
                    position: (389, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "munged.service",
                      position: (389, 21),
                     },
                    ],
                   },
                  ],
                  position: (389, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (391, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Type",
                       position: (392, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "forking",
                       position: (392, 17),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (393, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "wrappedSlurm",
                        position: (393, 24),
                       },
                      },
                      Raw {
                       content: "/bin/slurmctld",
                       position: (393, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PIDFile",
                       position: (394, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/slurmctld.pid",
                       position: (394, 20),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecReload",
                       position: (395, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (395, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "coreutils",
                           position: (395, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/bin/kill -HUP $MAINPID",
                       position: (395, 40),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (391, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "preStart",
                    position: (398, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mkdir -p ",
                    position: (399, 1),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (399, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateSaveLocation",
                        position: (399, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\nchown -R ",
                    position: (399, 42),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (400, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (400, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: ":slurm ",
                    position: (400, 29),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (400, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateSaveLocation",
                        position: (400, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (400, 60),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (383, 59),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (404, 5),
              },
              Raw {
               content: "services",
               position: (404, 13),
              },
              Raw {
               content: "slurmdbd",
               position: (404, 22),
              },
             ],
            },
            LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "configPath",
                  position: (406, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "$RUNTIME_DIRECTORY/slurmdbd.conf",
                  position: (406, 21),
                 },
                ],
               },
              ),
             ],
             target: FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (407, 8),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (407, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "dbdserver",
                   position: (407, 18),
                  },
                  Raw {
                   content: "enable",
                   position: (407, 28),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (408, 7),
                    },
                   ],
                  },
                  With {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (408, 19),
                   },
                   target: List {
                    elements: [
                     Variable {
                      identifier: "wrappedSlurm",
                      position: (408, 27),
                     },
                     Variable {
                      identifier: "munge",
                      position: (408, 40),
                     },
                     Variable {
                      identifier: "coreutils",
                      position: (408, 46),
                     },
                    ],
                    position: (408, 25),
                   },
                   position: (408, 14),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (410, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (410, 21),
                      },
                     ],
                    },
                   ],
                   position: (410, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (411, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (411, 18),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "munged.service",
                       position: (411, 35),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mysql.service",
                       position: (411, 52),
                      },
                     ],
                    },
                   ],
                   position: (411, 15),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "requires",
                     position: (412, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "munged.service",
                       position: (412, 21),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mysql.service",
                       position: (412, 38),
                      },
                     ],
                    },
                   ],
                   position: (412, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (414, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "install -m 600 -o ",
                     position: (415, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (415, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (415, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: " -T ",
                     position: (415, 38),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "slurmdbdConf",
                      position: (415, 44),
                     },
                    },
                    Raw {
                     content: " ",
                     position: (415, 57),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "configPath",
                      position: (415, 60),
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (415, 71),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "optionalString",
                       position: (416, 11),
                      },
                      arguments: [
                       BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (416, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "dbdserver",
                             position: (416, 31),
                            },
                            Raw {
                             content: "storagePassFile",
                             position: (416, 41),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (416, 60),
                         },
                        ],
                        position: (416, 57),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "echo \"StoragePass=$(cat ",
                          position: (417, 1),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (417, 37),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dbdserver",
                              position: (417, 41),
                             },
                             Raw {
                              content: "storagePassFile",
                              position: (417, 51),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: ")\" \\\n  >> ",
                          position: (417, 67),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "configPath",
                           position: (418, 18),
                          },
                         },
                         Raw {
                          content: "\n",
                          position: (418, 29),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (419, 12),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "script",
                     position: (422, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "export SLURM_CONF=",
                     position: (423, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "configPath",
                      position: (423, 29),
                     },
                    },
                    Raw {
                     content: "\nexec ",
                     position: (423, 40),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (424, 16),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (424, 20),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/slurmdbd -D\n",
                     position: (424, 28),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (427, 7),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "RuntimeDirectory",
                        position: (428, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "slurmdbd",
                        position: (428, 29),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Type",
                        position: (429, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "simple",
                        position: (429, 17),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PIDFile",
                        position: (430, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/run/slurmdbd.pid",
                        position: (430, 20),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecReload",
                        position: (431, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (431, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "coreutils",
                            position: (431, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/kill -HUP $MAINPID",
                        position: (431, 40),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (427, 23),
                  },
                 ),
                ],
                recursive: false,
                position: (407, 36),
               },
              ],
             },
             position: (404, 33),
            },
           ),
          ],
          recursive: false,
          position: (344, 36),
         },
        ],
       },
       position: (313, 5),
      },
     ),
    ],
    recursive: false,
    position: (55, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}