---
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: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    [
     Raw {
      content: "literalExpression",
      position: (4, 17),
     },
     Raw {
      content: "mkOption",
      position: (4, 35),
     },
     Raw {
      content: "types",
      position: (4, 44),
     },
    ],
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cfg",
       position: (5, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (5, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "security",
        position: (5, 16),
       },
       Raw {
        content: "dhparams",
        position: (5, 25),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "opt",
       position: (6, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "options",
      position: (6, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "security",
        position: (6, 17),
       },
       Raw {
        content: "dhparams",
        position: (6, 26),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "bitType",
       position: (8, 3),
      },
     ],
    },
    BinaryOperation {
     operator: Update,
     operands: [
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "types",
         position: (8, 13),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "addCheck",
           position: (8, 19),
          },
         ],
        },
        default: None,
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "types",
          position: (8, 28),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "int",
            position: (8, 34),
           },
          ],
         },
         default: None,
        },
        Function {
         argument: Some(
          "b",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: GreaterThanOrEqualTo,
          operands: [
           Variable {
            identifier: "b",
            position: (8, 42),
           },
           Int {
            value: 16,
            position: (8, 47),
           },
          ],
          position: (8, 44),
         },
         position: (8, 39),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "name",
            position: (9, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "bits",
            position: (9, 13),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "description",
            position: (10, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "integer of at least 16 bits",
            position: (10, 20),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (8, 54),
      },
     ],
     position: (8, 51),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "paramsSubmodule",
       position: (13, 3),
      },
     ],
    },
    Function {
     argument: None,
     arguments: FunctionArguments {
      arguments: [
       FunctionArgument {
        identifier: "config",
        default: None,
       },
       FunctionArgument {
        identifier: "name",
        default: None,
       },
      ],
      ellipsis: true,
     },
     definition: Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "options",
           position: (14, 5),
          },
          Raw {
           content: "bits",
           position: (14, 13),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (14, 20),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (15, 7),
               },
              ],
             },
             Variable {
              identifier: "bitType",
              position: (15, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (16, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (16, 17),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "defaultBitSize",
                 position: (16, 21),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "defaultText",
                position: (17, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (17, 21),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "config.",
                  position: (17, 40),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (17, 49),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultBitSize",
                      position: (17, 53),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (18, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The bit size for the prime that is used during a Diffie-Hellman\nkey exchange.\n",
                position: (19, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (14, 29),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "options",
           position: (24, 5),
          },
          Raw {
           content: "path",
           position: (24, 13),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (24, 20),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (25, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (25, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (25, 20),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "readOnly",
                position: (26, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (26, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (27, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The resulting path of the generated Diffie-Hellman parameters\nfile for other services to reference. This could be either a\nstore path or a file inside the directory specified by\n<option>security.dhparams.path</option>.\n",
                position: (28, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (24, 29),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "config",
           position: (35, 5),
          },
          Raw {
           content: "path",
           position: (35, 12),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "generated",
              position: (36, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (36, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "runCommand",
                position: (36, 24),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "dhparams-",
                position: (36, 36),
               },
               Expression {
                expression: Variable {
                 identifier: "name",
                 position: (36, 47),
                },
               },
               Raw {
                content: ".pem",
                position: (36, 52),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "nativeBuildInputs",
                   position: (37, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (37, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "openssl",
                      position: (37, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (37, 29),
                },
               ),
              ],
              recursive: false,
              position: (36, 58),
             },
             String {
              parts: [
               Raw {
                content: "openssl dhparam -out \"$out\" ",
                position: (38, 10),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (38, 42),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (38, 51),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (38, 58),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
             },
            ],
           },
          ),
         ],
         target: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (39, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "stateful",
              position: (39, 15),
             },
            ],
           },
           default: None,
          },
          then: String {
           parts: [
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (39, 32),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (39, 36),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/",
             position: (39, 41),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (39, 44),
             },
            },
            Raw {
             content: ".pem",
             position: (39, 49),
            },
           ],
          },
          else_: Variable {
           identifier: "generated",
           position: (39, 60),
          },
          position: (39, 8),
         },
         position: (35, 19),
        },
       ),
      ],
      recursive: false,
      position: (13, 44),
     },
     position: (13, 21),
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (43, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "security",
           position: (44, 5),
          },
          Raw {
           content: "dhparams",
           position: (44, 14),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "enable",
              position: (45, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (45, 16),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (46, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (46, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bool",
                    position: (46, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (47, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (47, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (48, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether to generate new DH params and clean up old DH params.\n",
                   position: (49, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (45, 25),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "params",
              position: (53, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (53, 16),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (54, 9),
                  },
                 ],
                },
                With {
                 expression: Variable {
                  identifier: "types",
                  position: (54, 21),
                 },
                 target: LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "coerce",
                       position: (55, 11),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "bits",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: Map {
                      bindings: [
                       Inherit(
                        None,
                        [
                         Raw {
                          content: "bits",
                          position: (55, 36),
                         },
                        ],
                       ),
                      ],
                      recursive: false,
                      position: (55, 26),
                     },
                     position: (55, 20),
                    },
                   ),
                  ],
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (56, 12),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "coercedTo",
                      position: (56, 21),
                     },
                     arguments: [
                      Variable {
                       identifier: "int",
                       position: (56, 31),
                      },
                      Variable {
                       identifier: "coerce",
                       position: (56, 35),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "submodule",
                        position: (56, 43),
                       },
                       arguments: [
                        Variable {
                         identifier: "paramsSubmodule",
                         position: (56, 53),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (54, 28),
                 },
                 position: (54, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (57, 9),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (57, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "example",
                   position: (58, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (58, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "literalExpression",
                     position: (58, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "{ nginx.bits = 3072; }",
                     position: (58, 42),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (59, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Diffie-Hellman parameters to generate.\n\nThe value is the size (in bits) of the DH params to generate. The\ngenerated DH params path can be found in\n<literal>config.security.dhparams.params.<replaceable>name</replaceable>.path</literal>.\n\n<note><para>The name of the DH params is taken as being the name of\nthe service it serves and the params will be generated before the\nsaid service is started.</para></note>\n\n<warning><para>If you are removing all dhparams from this list, you\nhave to leave <option>security.dhparams.enable</option> for at\nleast one activation in order to have them be cleaned up. This also\nmeans if you rollback to a version without any dhparams the\nexisting ones won't be cleaned up. Of course this only applies if\n<option>security.dhparams.stateful</option> is\n<literal>true</literal>.</para></warning>\n\n<note><title>For module implementers:</title><para>It's recommended\nto not set a specific bit size here, so that users can easily\noverride this by setting\n<option>security.dhparams.defaultBitSize</option>.</para></note>\n",
                   position: (60, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (53, 25),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "stateful",
              position: (85, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (85, 18),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (86, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (86, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bool",
                    position: (86, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (87, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (87, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (88, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether generation of Diffie-Hellman parameters should be stateful or\nnot. If this is enabled, PEM-encoded files for Diffie-Hellman\nparameters are placed in the directory specified by\n<option>security.dhparams.path</option>. Otherwise the files are\ncreated within the Nix store.\n\n<note><para>If this is <literal>false</literal> the resulting store\npath will be non-deterministic and will be rebuilt every time the\n<package>openssl</package> package changes.</para></note>\n",
                   position: (89, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (85, 27),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defaultBitSize",
              position: (101, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (101, 24),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (102, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "bitType",
                 position: (102, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (103, 9),
                  },
                 ],
                },
                Int {
                 value: 2048,
                 position: (103, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (104, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "This allows to override the default bit size for all of the\nDiffie-Hellman parameters set in\n<option>security.dhparams.params</option>.\n",
                   position: (105, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (101, 33),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "path",
              position: (111, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (111, 14),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (112, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (112, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (112, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (113, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/var/lib/dhparams",
                   position: (113, 20),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (114, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Path to the directory in which Diffie-Hellman parameters will be\nstored. This only is relevant if\n<option>security.dhparams.stateful</option> is\n<literal>true</literal>.\n",
                   position: (115, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (111, 23),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (44, 25),
        },
       ),
      ],
      recursive: false,
      position: (43, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (124, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (124, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "mkIf",
          position: (124, 16),
         },
        ],
       },
       default: None,
      },
      arguments: [
       BinaryOperation {
        operator: LogicalAnd,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (124, 22),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (124, 26),
            },
           ],
          },
          default: None,
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (124, 36),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "stateful",
             position: (124, 40),
            },
           ],
          },
          default: None,
         },
        ],
        position: (124, 33),
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "systemd",
             position: (125, 5),
            },
            Raw {
             content: "services",
             position: (125, 13),
            },
           ],
          },
          BinaryOperation {
           operator: Update,
           operands: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "dhparams-init",
                  position: (126, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (127, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Clean Up Old Diffie-Hellman Parameters",
                     position: (127, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (130, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (130, 23),
                      },
                     ],
                    },
                   ],
                   position: (130, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (132, 9),
                    },
                    Raw {
                     content: "RemainAfterExit",
                     position: (132, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (132, 41),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (133, 9),
                    },
                    Raw {
                     content: "Type",
                     position: (133, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "oneshot",
                     position: (133, 31),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "script",
                     position: (135, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "if [ ! -d ",
                     position: (136, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (136, 23),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (136, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: " ]; then\n  mkdir -p ",
                     position: (136, 32),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (137, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (137, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\nfi\n\n# Remove old dhparams\nfor file in ",
                     position: (137, 33),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (141, 25),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (141, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/*; do\n  if [ ! -f \"$file\" ]; then\n    continue\n  fi\n  ",
                     position: (141, 34),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (145, 15),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "concatStrings",
                          position: (145, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "lib",
                          position: (145, 34),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "mapAttrsToList",
                            position: (145, 38),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Function {
                          argument: Some(
                           "name",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: Function {
                           argument: None,
                           arguments: FunctionArguments {
                            arguments: [
                             FunctionArgument {
                              identifier: "path",
                              default: None,
                             },
                             FunctionArgument {
                              identifier: "bits",
                              default: None,
                             },
                            ],
                            ellipsis: true,
                           },
                           definition: String {
                            parts: [
                             Raw {
                              content: "if [ \"$file\" = ",
                              position: (146, 1),
                             },
                             Expression {
                              expression: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "lib",
                                 position: (146, 32),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "escapeShellArg",
                                   position: (146, 36),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (146, 51),
                                },
                               ],
                              },
                             },
                             Raw {
                              content: " ] && \\\n   ",
                              position: (146, 56),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "pkgs",
                                position: (147, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "openssl",
                                  position: (147, 25),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: "/bin/openssl dhparam -in \"$file\" -text \\\n   | head -n 1 | grep \"(",
                              position: (147, 33),
                             },
                             Expression {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "toString",
                                position: (148, 41),
                               },
                               arguments: [
                                Variable {
                                 identifier: "bits",
                                 position: (148, 50),
                                },
                               ],
                              },
                             },
                             Raw {
                              content: " bit)\" > /dev/null; then\n  continue\nfi\n",
                              position: (148, 55),
                             },
                            ],
                           },
                           position: (145, 60),
                          },
                          position: (145, 54),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (151, 17),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "params",
                             position: (151, 21),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\n  rm $file\ndone\n\n# TODO: Ideally this would be removing the *former* cfg.path, though\n# this does not seem really important as changes to it are quite\n# unlikely\nrmdir --ignore-fail-on-non-empty ",
                     position: (151, 29),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (158, 46),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (158, 50),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (158, 55),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (126, 23),
               },
              ),
             ],
             recursive: false,
             position: (125, 24),
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (161, 10),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "mapAttrs'",
                 position: (161, 14),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: None,
                arguments: FunctionArguments {
                 arguments: [
                  FunctionArgument {
                   identifier: "path",
                   default: None,
                  },
                  FunctionArgument {
                   identifier: "bits",
                   default: None,
                  },
                 ],
                 ellipsis: true,
                },
                definition: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (161, 52),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "nameValuePair",
                     position: (161, 56),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "dhparams-gen-",
                     position: (161, 71),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "name",
                      position: (161, 86),
                     },
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "description",
                        position: (162, 7),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "Generate Diffie-Hellman Parameters for ",
                        position: (162, 22),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "name",
                         position: (162, 63),
                        },
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "after",
                        position: (163, 7),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "dhparams-init.service",
                          position: (163, 18),
                         },
                        ],
                       },
                      ],
                      position: (163, 15),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "before",
                        position: (164, 7),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (164, 21),
                          },
                         },
                         Raw {
                          content: ".service",
                          position: (164, 26),
                         },
                        ],
                       },
                      ],
                      position: (164, 16),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "wantedBy",
                        position: (165, 7),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "multi-user.target",
                          position: (165, 21),
                         },
                        ],
                       },
                      ],
                      position: (165, 18),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "unitConfig",
                        position: (166, 7),
                       },
                       Raw {
                        content: "ConditionPathExists",
                        position: (166, 18),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "!",
                        position: (166, 41),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "path",
                         position: (166, 44),
                        },
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "serviceConfig",
                        position: (167, 7),
                       },
                       Raw {
                        content: "Type",
                        position: (167, 21),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "oneshot",
                        position: (167, 29),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "script",
                        position: (168, 7),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mkdir -p ",
                        position: (169, 1),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (169, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "escapeShellArg",
                             position: (169, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (169, 39),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "path",
                              position: (169, 43),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (169, 48),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (170, 11),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "openssl",
                            position: (170, 16),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/openssl dhparam -out ",
                        position: (170, 24),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (170, 52),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "escapeShellArg",
                             position: (170, 56),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Variable {
                           identifier: "path",
                           position: (170, 71),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " \\\n  ",
                        position: (170, 76),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toString",
                          position: (171, 13),
                         },
                         arguments: [
                          Variable {
                           identifier: "bits",
                           position: (171, 22),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (171, 27),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (161, 93),
                  },
                 ],
                },
                position: (161, 31),
               },
               position: (161, 25),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (173, 8),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "params",
                  position: (173, 12),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
           position: (161, 7),
          },
         ),
        ],
        recursive: false,
        position: (124, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "meta",
        position: (176, 3),
       },
       Raw {
        content: "maintainers",
        position: (176, 8),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (176, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "maintainers",
          position: (176, 31),
         },
        ],
       },
       default: None,
      },
      target: List {
       elements: [
        Variable {
         identifier: "ekleog",
         position: (176, 46),
        },
       ],
       position: (176, 44),
      },
      position: (176, 22),
     },
    ),
   ],
   recursive: false,
   position: (42, 4),
  },
  position: (3, 1),
 },
 position: (1, 1),
}