---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "options",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   Inherit {
    from: Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    attributes: [
     Raw {
      content: "literalExpression",
      position: (4, 17),
     },
     Raw {
      content: "mkOption",
      position: (4, 35),
     },
     Raw {
      content: "types",
      position: (4, 44),
     },
    ],
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "cfg",
       position: (5, 3),
      },
     ],
    },
    to: PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (5, 9),
     },
     attribute_path: AttributePath {
      parts: [
       Raw {
        content: "security",
        position: (5, 16),
       },
       Raw {
        content: "dhparams",
        position: (5, 25),
       },
      ],
     },
     default: None,
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "opt",
       position: (6, 3),
      },
     ],
    },
    to: PropertyAccess {
     expression: Variable {
      identifier: "options",
      position: (6, 9),
     },
     attribute_path: AttributePath {
      parts: [
       Raw {
        content: "security",
        position: (6, 17),
       },
       Raw {
        content: "dhparams",
        position: (6, 26),
       },
      ],
     },
     default: None,
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "bitType",
       position: (8, 3),
      },
     ],
    },
    to: BinaryOperation {
     operator: Update,
     operands: [
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "types",
         position: (8, 13),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "addCheck",
           position: (8, 19),
          },
         ],
        },
        default: None,
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "types",
          position: (8, 28),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "int",
            position: (8, 34),
           },
          ],
         },
         default: None,
        },
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "b",
          },
          definition: BinaryOperation {
           operator: GreaterThanOrEqualTo,
           operands: [
            Variable {
             identifier: "b",
             position: (8, 42),
            },
            Int {
             value: 16,
             position: (8, 47),
            },
           ],
           position: (8, 44),
          },
          position: (8, 39),
         },
         position: (8, 38),
        },
       ],
      },
      Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "name",
            position: (9, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "bits",
            position: (9, 13),
           },
          ],
          position: (9, 12),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "description",
            position: (10, 5),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "integer of at least 16 bits",
            position: (10, 20),
           },
          ],
          position: (10, 19),
         },
        },
       ],
       recursive: false,
       position: (8, 54),
      },
     ],
     position: (8, 51),
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "paramsSubmodule",
       position: (13, 3),
      },
     ],
    },
    to: Function {
     argument: Destructured {
      identifier: None,
      arguments: [
       DestructuredArgument {
        identifier: "name",
        default: None,
       },
       DestructuredArgument {
        identifier: "config",
        default: None,
       },
      ],
      ellipsis: true,
     },
     definition: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "options",
           position: (14, 5),
          },
          Raw {
           content: "bits",
           position: (14, 13),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (14, 20),
         },
         arguments: [
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (15, 7),
               },
              ],
             },
             to: Variable {
              identifier: "bitType",
              position: (15, 14),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "default",
                position: (16, 7),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (16, 17),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "defaultBitSize",
                 position: (16, 21),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "defaultText",
                position: (17, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (17, 21),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "config.",
                  position: (17, 40),
                 },
                 Interpolation {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (17, 49),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "defaultBitSize",
                      position: (17, 53),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                ],
                position: (17, 39),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "description",
                position: (18, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "The bit size for the prime that is used during a Diffie-Hellman\nkey exchange.\n",
                position: (19, 1),
               },
              ],
              position: (18, 21),
             },
            },
           ],
           recursive: false,
           position: (14, 29),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "options",
           position: (24, 5),
          },
          Raw {
           content: "path",
           position: (24, 13),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (24, 20),
         },
         arguments: [
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (25, 7),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (25, 14),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (25, 20),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "readOnly",
                position: (26, 7),
               },
              ],
             },
             to: Variable {
              identifier: "true",
              position: (26, 18),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "description",
                position: (27, 7),
               },
              ],
             },
             to: 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),
               },
              ],
              position: (27, 21),
             },
            },
           ],
           recursive: false,
           position: (24, 29),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "config",
           position: (35, 5),
          },
          Raw {
           content: "path",
           position: (35, 12),
          },
         ],
        },
        to: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "generated",
              position: (36, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (36, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "runCommand",
                position: (36, 24),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "dhparams-",
                position: (36, 36),
               },
               Interpolation {
                expression: Variable {
                 identifier: "name",
                 position: (36, 47),
                },
               },
               Raw {
                content: ".pem",
                position: (36, 52),
               },
              ],
              position: (36, 35),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "nativeBuildInputs",
                   position: (37, 9),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (37, 31),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     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),
               },
               Interpolation {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (38, 42),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (38, 51),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "bits",
                      position: (38, 58),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
              position: (38, 9),
             },
            ],
           },
          },
         ],
         target: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (39, 11),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "stateful",
              position: (39, 15),
             },
            ],
           },
           default: None,
          },
          then: String {
           parts: [
            Interpolation {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (39, 32),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (39, 36),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/",
             position: (39, 41),
            },
            Interpolation {
             expression: Variable {
              identifier: "name",
              position: (39, 44),
             },
            },
            Raw {
             content: ".pem",
             position: (39, 49),
            },
           ],
           position: (39, 29),
          },
          else_: Variable {
           identifier: "generated",
           position: (39, 60),
          },
          position: (39, 8),
         },
         position: (35, 19),
        },
       },
      ],
      recursive: false,
      position: (13, 44),
     },
     position: (13, 21),
    },
   },
  ],
  target: Map {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "options",
        position: (43, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "security",
           position: (44, 5),
          },
          Raw {
           content: "dhparams",
           position: (44, 14),
          },
         ],
        },
        to: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "enable",
              position: (45, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (45, 16),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (46, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (46, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "bool",
                    position: (46, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (47, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "false",
                 position: (47, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (48, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Whether to generate new DH params and clean up old DH params.\n",
                   position: (49, 1),
                  },
                 ],
                 position: (48, 23),
                },
               },
              ],
              recursive: false,
              position: (45, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "params",
              position: (53, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (53, 16),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (54, 9),
                  },
                 ],
                },
                to: With {
                 expression: Variable {
                  identifier: "types",
                  position: (54, 21),
                 },
                 target: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "coerce",
                       position: (55, 11),
                      },
                     ],
                    },
                    to: Function {
                     argument: Simple {
                      identifier: "bits",
                     },
                     definition: Map {
                      bindings: [
                       Inherit {
                        from: None,
                        attributes: [
                         Raw {
                          content: "bits",
                          position: (55, 36),
                         },
                        ],
                       },
                      ],
                      recursive: false,
                      position: (55, 26),
                     },
                     position: (55, 20),
                    },
                   },
                  ],
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (56, 12),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "coercedTo",
                       position: (56, 21),
                      },
                      arguments: [
                       Variable {
                        identifier: "int",
                        position: (56, 31),
                       },
                       Variable {
                        identifier: "coerce",
                        position: (56, 35),
                       },
                       Parentheses {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "submodule",
                          position: (56, 43),
                         },
                         arguments: [
                          Variable {
                           identifier: "paramsSubmodule",
                           position: (56, 53),
                          },
                         ],
                        },
                        position: (56, 42),
                       },
                      ],
                     },
                     position: (56, 20),
                    },
                   ],
                  },
                  position: (54, 28),
                 },
                 position: (54, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (57, 9),
                  },
                 ],
                },
                to: Map {
                 bindings: [],
                 recursive: false,
                 position: (57, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "example",
                   position: (58, 9),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (58, 19),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "literalExpression",
                     position: (58, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "{ nginx.bits = 3072; }",
                     position: (58, 42),
                    },
                   ],
                   position: (58, 41),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (59, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (59, 23),
                },
               },
              ],
              recursive: false,
              position: (53, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "stateful",
              position: (85, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (85, 18),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (86, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (86, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "bool",
                    position: (86, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (87, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (87, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (88, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (88, 23),
                },
               },
              ],
              recursive: false,
              position: (85, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defaultBitSize",
              position: (101, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (101, 24),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (102, 9),
                  },
                 ],
                },
                to: Variable {
                 identifier: "bitType",
                 position: (102, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (103, 9),
                  },
                 ],
                },
                to: Int {
                 value: 2048,
                 position: (103, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (104, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (104, 23),
                },
               },
              ],
              recursive: false,
              position: (101, 33),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "path",
              position: (111, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (111, 14),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (112, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (112, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (112, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (113, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "/var/lib/dhparams",
                   position: (113, 20),
                  },
                 ],
                 position: (113, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (114, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (114, 23),
                },
               },
              ],
              recursive: false,
              position: (111, 23),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (44, 25),
        },
       },
      ],
      recursive: false,
      position: (43, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "config",
        position: (124, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (124, 12),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "mkIf",
          position: (124, 16),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Parentheses {
        expression: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (124, 22),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "enable",
              position: (124, 26),
             },
            ],
           },
           default: None,
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (124, 36),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "stateful",
              position: (124, 40),
             },
            ],
           },
           default: None,
          },
         ],
         position: (124, 33),
        },
        position: (124, 21),
       },
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "systemd",
             position: (125, 5),
            },
            Raw {
             content: "services",
             position: (125, 13),
            },
           ],
          },
          to: BinaryOperation {
           operator: Update,
           operands: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "dhparams-init",
                  position: (126, 7),
                 },
                ],
               },
               to: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (127, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Clean Up Old Diffie-Hellman Parameters",
                     position: (127, 24),
                    },
                   ],
                   position: (127, 23),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "wantedBy",
                     position: (130, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (130, 23),
                      },
                     ],
                     position: (130, 22),
                    },
                   ],
                   position: (130, 20),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "serviceConfig",
                     position: (132, 9),
                    },
                    Raw {
                     content: "RemainAfterExit",
                     position: (132, 23),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (132, 41),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "serviceConfig",
                     position: (133, 9),
                    },
                    Raw {
                     content: "Type",
                     position: (133, 23),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "oneshot",
                     position: (133, 31),
                    },
                   ],
                   position: (133, 30),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "script",
                     position: (135, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "if [ ! -d ",
                     position: (136, 1),
                    },
                    Interpolation {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (136, 23),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "path",
                         position: (136, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: " ]; then\n  mkdir -p ",
                     position: (136, 32),
                    },
                    Interpolation {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (137, 24),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "path",
                         position: (137, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\nfi\n\n# Remove old dhparams\nfor file in ",
                     position: (137, 33),
                    },
                    Interpolation {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (141, 25),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "path",
                         position: (141, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/*; do\n  if [ ! -f \"$file\" ]; then\n    continue\n  fi\n  ",
                     position: (141, 34),
                    },
                    Interpolation {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (145, 15),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "concatStrings",
                          position: (145, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Parentheses {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (145, 34),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "mapAttrsToList",
                             position: (145, 38),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Parentheses {
                           expression: Function {
                            argument: Simple {
                             identifier: "name",
                            },
                            definition: Function {
                             argument: Destructured {
                              identifier: None,
                              arguments: [
                               DestructuredArgument {
                                identifier: "bits",
                                default: None,
                               },
                               DestructuredArgument {
                                identifier: "path",
                                default: None,
                               },
                              ],
                              ellipsis: true,
                             },
                             definition: String {
                              parts: [
                               Raw {
                                content: "if [ \"$file\" = ",
                                position: (146, 1),
                               },
                               Interpolation {
                                expression: FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "lib",
                                   position: (146, 32),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "escapeShellArg",
                                     position: (146, 36),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "path",
                                   position: (146, 51),
                                  },
                                 ],
                                },
                               },
                               Raw {
                                content: " ] && \\\n   ",
                                position: (146, 56),
                               },
                               Interpolation {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (147, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "openssl",
                                    position: (147, 25),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/openssl dhparam -in \"$file\" -text \\\n   | head -n 1 | grep \"(",
                                position: (147, 33),
                               },
                               Interpolation {
                                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, 81),
                             },
                             position: (145, 60),
                            },
                            position: (145, 54),
                           },
                           position: (145, 53),
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (151, 17),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "params",
                              position: (151, 21),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        position: (145, 33),
                       },
                      ],
                     },
                    },
                    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),
                    },
                    Interpolation {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (158, 46),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "path",
                         position: (158, 50),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (158, 55),
                    },
                   ],
                   position: (135, 18),
                  },
                 },
                ],
                recursive: false,
                position: (126, 23),
               },
              },
             ],
             recursive: false,
             position: (125, 24),
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (161, 10),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "mapAttrs'",
                 position: (161, 14),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "name",
                },
                definition: Function {
                 argument: Destructured {
                  identifier: None,
                  arguments: [
                   DestructuredArgument {
                    identifier: "bits",
                    default: None,
                   },
                   DestructuredArgument {
                    identifier: "path",
                    default: None,
                   },
                  ],
                  ellipsis: true,
                 },
                 definition: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (161, 52),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nameValuePair",
                      position: (161, 56),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "dhparams-gen-",
                      position: (161, 71),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "name",
                       position: (161, 86),
                      },
                     },
                    ],
                    position: (161, 70),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "description",
                         position: (162, 7),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "Generate Diffie-Hellman Parameters for ",
                         position: (162, 22),
                        },
                        Interpolation {
                         expression: Variable {
                          identifier: "name",
                          position: (162, 63),
                         },
                        },
                       ],
                       position: (162, 21),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "after",
                         position: (163, 7),
                        },
                       ],
                      },
                      to: List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "dhparams-init.service",
                           position: (163, 18),
                          },
                         ],
                         position: (163, 17),
                        },
                       ],
                       position: (163, 15),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "before",
                         position: (164, 7),
                        },
                       ],
                      },
                      to: List {
                       elements: [
                        String {
                         parts: [
                          Interpolation {
                           expression: Variable {
                            identifier: "name",
                            position: (164, 21),
                           },
                          },
                          Raw {
                           content: ".service",
                           position: (164, 26),
                          },
                         ],
                         position: (164, 18),
                        },
                       ],
                       position: (164, 16),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "wantedBy",
                         position: (165, 7),
                        },
                       ],
                      },
                      to: List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (165, 21),
                          },
                         ],
                         position: (165, 20),
                        },
                       ],
                       position: (165, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "unitConfig",
                         position: (166, 7),
                        },
                        Raw {
                         content: "ConditionPathExists",
                         position: (166, 18),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "!",
                         position: (166, 41),
                        },
                        Interpolation {
                         expression: Variable {
                          identifier: "path",
                          position: (166, 44),
                         },
                        },
                       ],
                       position: (166, 40),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "serviceConfig",
                         position: (167, 7),
                        },
                        Raw {
                         content: "Type",
                         position: (167, 21),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "oneshot",
                         position: (167, 29),
                        },
                       ],
                       position: (167, 28),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "script",
                         position: (168, 7),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "mkdir -p ",
                         position: (169, 1),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "lib",
                            position: (169, 20),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "escapeShellArg",
                              position: (169, 24),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (169, 39),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "path",
                               position: (169, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (169, 48),
                        },
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (170, 11),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "openssl",
                             position: (170, 16),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/openssl dhparam -out ",
                         position: (170, 24),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "lib",
                            position: (170, 52),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "escapeShellArg",
                              position: (170, 56),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           Variable {
                            identifier: "path",
                            position: (170, 71),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: " \\\n  ",
                         position: (170, 76),
                        },
                        Interpolation {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (171, 13),
                          },
                          arguments: [
                           Variable {
                            identifier: "bits",
                            position: (171, 22),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (171, 27),
                        },
                       ],
                       position: (168, 16),
                      },
                     },
                    ],
                    recursive: false,
                    position: (161, 93),
                   },
                  ],
                 },
                 position: (161, 31),
                },
                position: (161, 25),
               },
               position: (161, 24),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (173, 8),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "params",
                  position: (173, 12),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
           position: (161, 7),
          },
         },
        ],
        recursive: false,
        position: (124, 50),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "meta",
        position: (176, 3),
       },
       Raw {
        content: "maintainers",
        position: (176, 8),
       },
      ],
     },
     to: With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (176, 27),
       },
       attribute_path: AttributePath {
        parts: [
         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),
}