---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "systemdUtils",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: With {
  expression: PropertyAccess {
   expression: Variable {
    identifier: "systemdUtils",
    position: (3, 6),
   },
   attribute_path: AttributePath {
    parts: [
     Raw {
      content: "lib",
      position: (3, 19),
     },
    ],
   },
   default: None,
  },
  target: With {
   expression: Variable {
    identifier: "lib",
    position: (4, 6),
   },
   target: LetIn {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "checkService",
         position: (7, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "checkUnitConfig",
        position: (7, 18),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "Service",
           position: (7, 35),
          },
         ],
         position: (7, 34),
        },
        List {
         elements: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "assertValueOneOf",
             position: (8, 6),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "Type",
                position: (8, 24),
               },
              ],
              position: (8, 23),
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "exec",
                  position: (9, 8),
                 },
                ],
                position: (9, 7),
               },
               String {
                parts: [
                 Raw {
                  content: "simple",
                  position: (9, 15),
                 },
                ],
                position: (9, 14),
               },
               String {
                parts: [
                 Raw {
                  content: "forking",
                  position: (9, 24),
                 },
                ],
                position: (9, 23),
               },
               String {
                parts: [
                 Raw {
                  content: "oneshot",
                  position: (9, 34),
                 },
                ],
                position: (9, 33),
               },
               String {
                parts: [
                 Raw {
                  content: "dbus",
                  position: (9, 44),
                 },
                ],
                position: (9, 43),
               },
               String {
                parts: [
                 Raw {
                  content: "notify",
                  position: (9, 51),
                 },
                ],
                position: (9, 50),
               },
               String {
                parts: [
                 Raw {
                  content: "idle",
                  position: (9, 60),
                 },
                ],
                position: (9, 59),
               },
              ],
              position: (8, 30),
             },
            ],
           },
           position: (8, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "assertValueOneOf",
             position: (11, 6),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "Restart",
                position: (11, 24),
               },
              ],
              position: (11, 23),
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "no",
                  position: (12, 8),
                 },
                ],
                position: (12, 7),
               },
               String {
                parts: [
                 Raw {
                  content: "on-success",
                  position: (12, 13),
                 },
                ],
                position: (12, 12),
               },
               String {
                parts: [
                 Raw {
                  content: "on-failure",
                  position: (12, 26),
                 },
                ],
                position: (12, 25),
               },
               String {
                parts: [
                 Raw {
                  content: "on-abnormal",
                  position: (12, 39),
                 },
                ],
                position: (12, 38),
               },
               String {
                parts: [
                 Raw {
                  content: "on-abort",
                  position: (12, 53),
                 },
                ],
                position: (12, 52),
               },
               String {
                parts: [
                 Raw {
                  content: "always",
                  position: (12, 64),
                 },
                ],
                position: (12, 63),
               },
              ],
              position: (11, 33),
             },
            ],
           },
           position: (11, 5),
          },
         ],
         position: (7, 44),
        },
       ],
      },
     },
    ],
    target: Map {
     bindings: [
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "unitOption",
          position: (18, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mkOptionType",
         position: (18, 16),
        },
        arguments: [
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (19, 5),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "systemd option",
               position: (19, 13),
              },
             ],
             position: (19, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "merge",
               position: (20, 5),
              },
             ],
            },
            to: Function {
             argument: Simple {
              identifier: "loc",
             },
             definition: Function {
              argument: Simple {
               identifier: "defs",
              },
              definition: LetIn {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defs'",
                    position: (22, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "filterOverrides",
                   position: (22, 17),
                  },
                  arguments: [
                   Variable {
                    identifier: "defs",
                    position: (22, 33),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defs''",
                    position: (23, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "getValues",
                   position: (23, 18),
                  },
                  arguments: [
                   Variable {
                    identifier: "defs'",
                    position: (23, 28),
                   },
                  ],
                 },
                },
               ],
               target: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "isList",
                  position: (25, 12),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "head",
                     position: (25, 20),
                    },
                    arguments: [
                     Variable {
                      identifier: "defs''",
                      position: (25, 25),
                     },
                    ],
                   },
                   position: (25, 19),
                  },
                 ],
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "concatLists",
                  position: (26, 14),
                 },
                 arguments: [
                  Variable {
                   identifier: "defs''",
                   position: (26, 26),
                  },
                 ],
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "mergeEqualOption",
                  position: (27, 14),
                 },
                 arguments: [
                  Variable {
                   identifier: "loc",
                   position: (27, 31),
                  },
                  Variable {
                   identifier: "defs'",
                   position: (27, 35),
                  },
                 ],
                },
                position: (25, 9),
               },
               position: (21, 7),
              },
              position: (20, 18),
             },
             position: (20, 13),
            },
           },
          ],
          recursive: false,
          position: (18, 29),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "sharedOptions",
          position: (30, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "enable",
             position: (32, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (32, 14),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (33, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (33, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (34, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (34, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (34, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (35, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "If set to false, this unit will be a symlink to\n/dev/null. This is primarily useful to prevent specific\ntemplate instances\n(e.g. <literal>serial-getty@ttyS0</literal>) from being\nstarted. Note that <literal>enable=true</literal> does not\nmake a unit start by default at boot; if you want that, see\n<literal>wantedBy</literal>.\n",
                  position: (36, 1),
                 },
                ],
                position: (35, 21),
               },
              },
             ],
             recursive: false,
             position: (32, 23),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "requiredBy",
             position: (46, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (46, 18),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (47, 7),
                 },
                ],
               },
               to: List {
                elements: [],
                position: (47, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (48, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (48, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "listOf",
                    position: (48, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (48, 27),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (49, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Units that require (i.e. depend on and need to go down with)\nthis unit. The discussion under <literal>wantedBy</literal>\napplies here as well: inverse <literal>.requires</literal>\nsymlinks are established.\n",
                  position: (50, 1),
                 },
                ],
                position: (49, 21),
               },
              },
             ],
             recursive: false,
             position: (46, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "wantedBy",
             position: (57, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (57, 16),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (58, 7),
                 },
                ],
               },
               to: List {
                elements: [],
                position: (58, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (59, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (59, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "listOf",
                    position: (59, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (59, 27),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (60, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Units that want (i.e. depend on) this unit. The standard way\nto make a unit start by default at boot is to set this option\nto <literal>[ \"multi-user.target\" ]</literal>. That's despite\nthe fact that the systemd.unit(5) manpage says this option\ngoes in the <literal>[Install]</literal> section that controls\nthe behaviour of <literal>systemctl enable</literal>. Since\nsuch a process is stateful and thus contrary to the design of\nNixOS, setting this option instead causes the equivalent\ninverse <literal>.wants</literal> symlink to be present,\nestablishing the same desired relationship in a stateless way.\n",
                  position: (61, 1),
                 },
                ],
                position: (60, 21),
               },
              },
             ],
             recursive: false,
             position: (57, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "aliases",
             position: (74, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (74, 15),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (75, 7),
                 },
                ],
               },
               to: List {
                elements: [],
                position: (75, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (76, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (76, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "listOf",
                    position: (76, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (76, 27),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (77, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Aliases of that unit.",
                  position: (77, 22),
                 },
                ],
                position: (77, 21),
               },
              },
             ],
             recursive: false,
             position: (74, 24),
            },
           ],
          },
         },
        ],
        recursive: false,
        position: (30, 19),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "concreteUnitOptions",
          position: (82, 3),
         },
        ],
       },
       to: BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "sharedOptions",
          position: (82, 25),
         },
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "text",
               position: (84, 5),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (84, 12),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (85, 7),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (85, 14),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (85, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (85, 27),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (85, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (86, 7),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (86, 17),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (87, 7),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Text of this systemd unit.",
                    position: (87, 22),
                   },
                  ],
                  position: (87, 21),
                 },
                },
               ],
               recursive: false,
               position: (84, 21),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "unit",
               position: (90, 5),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (90, 12),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "internal",
                    position: (91, 7),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (91, 18),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (92, 7),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The generated unit.",
                    position: (92, 22),
                   },
                  ],
                  position: (92, 21),
                 },
                },
               ],
               recursive: false,
               position: (90, 21),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (82, 42),
         },
        ],
        position: (82, 39),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "commonUnitOptions",
          position: (97, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (98, 5),
            },
           ],
          },
          to: BinaryOperation {
           operator: Update,
           operands: [
            Variable {
             identifier: "sharedOptions",
             position: (98, 15),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (100, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (100, 21),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (101, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [],
                     position: (101, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (102, 9),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (102, 16),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "singleLineStr",
                        position: (102, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (103, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Description of this unit used in systemd messages and progress indicators.",
                       position: (103, 24),
                      },
                     ],
                     position: (103, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (100, 30),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "documentation",
                  position: (106, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (106, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (107, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (107, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (108, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (108, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (108, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (108, 29),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "str",
                          position: (108, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (109, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "A list of URIs referencing documentation for this unit or its configuration.",
                       position: (109, 24),
                      },
                     ],
                     position: (109, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (106, 32),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "requires",
                  position: (112, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (112, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (113, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (113, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (114, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (114, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (114, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (114, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (115, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Start the specified units when this unit is started, and stop\nthis unit when the specified units are stopped or fail.\n",
                       position: (116, 1),
                      },
                     ],
                     position: (115, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (112, 27),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "wants",
                  position: (121, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (121, 15),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (122, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (122, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (123, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (123, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (123, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (123, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (124, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Start the specified units when this unit is started.\n",
                       position: (125, 1),
                      },
                     ],
                     position: (124, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (121, 24),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "after",
                  position: (129, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (129, 15),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (130, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (130, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (131, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (131, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (131, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (131, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (132, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "If the specified units are started at the same time as\nthis unit, delay this unit until they have started.\n",
                       position: (133, 1),
                      },
                     ],
                     position: (132, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (129, 24),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "before",
                  position: (138, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (138, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (139, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (139, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (140, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (140, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (140, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (140, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (141, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "If the specified units are started at the same time as\nthis unit, delay them until this unit has started.\n",
                       position: (142, 1),
                      },
                     ],
                     position: (141, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (138, 25),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "bindsTo",
                  position: (147, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (147, 17),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (148, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (148, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (149, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (149, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (149, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (149, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (150, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Like ‘requires’, but in addition, if the specified units\nunexpectedly disappear, this unit will be stopped as well.\n",
                       position: (151, 1),
                      },
                     ],
                     position: (150, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (147, 26),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "partOf",
                  position: (156, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (156, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (157, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (157, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (158, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (158, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (158, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (158, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (159, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "If the specified units are stopped or restarted, then this\nunit is stopped or restarted as well.\n",
                       position: (160, 1),
                      },
                     ],
                     position: (159, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (156, 25),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "conflicts",
                  position: (165, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (165, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (166, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (166, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (167, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (167, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (167, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (167, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (168, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "If the specified units are started, then this unit is stopped\nand vice versa.\n",
                       position: (169, 1),
                      },
                     ],
                     position: (168, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (165, 28),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "requisite",
                  position: (174, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (174, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (175, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (175, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (176, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (176, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (176, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (176, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (177, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Similar to requires. However if the units listed are not started,\nthey will not be started and the transaction will fail.\n",
                       position: (178, 1),
                      },
                     ],
                     position: (177, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (174, 28),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "unitConfig",
                  position: (183, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (183, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (184, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [],
                     recursive: false,
                     position: (184, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "example",
                       position: (185, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "RequiresMountsFor",
                          position: (185, 21),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "/data",
                          position: (185, 42),
                         },
                        ],
                        position: (185, 41),
                       },
                      },
                     ],
                     recursive: false,
                     position: (185, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (186, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (186, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "attrsOf",
                         position: (186, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitOption",
                       position: (186, 30),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (187, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Each attribute in this set specifies an option in the\n<literal>[Unit]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.unit</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                       position: (188, 1),
                      },
                     ],
                     position: (187, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (183, 29),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "onFailure",
                  position: (195, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (195, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (196, 9),
                      },
                     ],
                    },
                    to: List {
                     elements: [],
                     position: (196, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (197, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (197, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listOf",
                         position: (197, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "unitNameType",
                       position: (197, 29),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (198, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "A list of one or more units that are activated when\nthis unit enters the \"failed\" state.\n",
                       position: (199, 1),
                      },
                     ],
                     position: (198, 23),
                    },
                   },
                  ],
                  recursive: false,
                  position: (195, 28),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "startLimitBurst",
                  position: (204, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (204, 25),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (205, 10),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (205, 17),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "int",
                        position: (205, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (206, 10),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Configure unit start rate limiting. Units which are started\nmore than startLimitBurst times within an interval time\ninterval are not permitted to start any more.\n",
                       position: (207, 1),
                      },
                     ],
                     position: (206, 24),
                    },
                   },
                  ],
                  recursive: false,
                  position: (204, 34),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "startLimitIntervalSec",
                  position: (213, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (213, 31),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (214, 10),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (214, 17),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "int",
                        position: (214, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (215, 10),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Configure unit start rate limiting. Units which are started\nmore than startLimitBurst times within an interval time\ninterval are not permitted to start any more.\n",
                       position: (216, 1),
                      },
                     ],
                     position: (215, 24),
                    },
                   },
                  ],
                  recursive: false,
                  position: (213, 40),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (98, 32),
            },
           ],
           position: (98, 29),
          },
         },
        ],
        recursive: false,
        position: (97, 23),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2CommonUnitOptions",
          position: (225, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (226, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "commonUnitOptions",
             position: (227, 7),
            },
           ],
           position: (226, 15),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (230, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "restartTriggers",
                position: (231, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (231, 25),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (232, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [],
                   position: (232, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (233, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (233, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "listOf",
                       position: (233, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (233, 29),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "unspecified",
                        position: (233, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (234, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "An arbitrary list of items such as derivations.  If any item\nin the list changes between reconfigurations, the service will\nbe restarted.\n",
                     position: (235, 1),
                    },
                   ],
                   position: (234, 23),
                  },
                 },
                ],
                recursive: false,
                position: (231, 34),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "reloadTriggers",
                position: (241, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (241, 24),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (242, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [],
                   position: (242, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (243, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (243, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "listOf",
                       position: (243, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (243, 29),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (244, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "An arbitrary list of items such as derivations.  If any item\nin the list changes between reconfigurations, the service will\nbe reloaded.  If anything but a reload trigger changes in the\nunit file, the unit will be restarted instead.\n",
                     position: (245, 1),
                    },
                   ],
                   position: (244, 23),
                  },
                 },
                ],
                recursive: false,
                position: (241, 33),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (230, 15),
          },
         },
        ],
        recursive: false,
        position: (225, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1CommonUnitOptions",
          position: (253, 3),
         },
        ],
       },
       to: Variable {
        identifier: "commonUnitOptions",
        position: (253, 29),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "serviceOptions",
          position: (255, 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: (256, 5),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "environment",
                 position: (258, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (258, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (259, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [],
                    recursive: false,
                    position: (259, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (260, 9),
                     },
                    ],
                   },
                   to: With {
                    expression: Variable {
                     identifier: "types",
                     position: (260, 21),
                    },
                    target: FunctionApplication {
                     function: Variable {
                      identifier: "attrsOf",
                      position: (260, 28),
                     },
                     arguments: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "nullOr",
                         position: (260, 37),
                        },
                        arguments: [
                         Parentheses {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "oneOf",
                            position: (260, 45),
                           },
                           arguments: [
                            List {
                             elements: [
                              Variable {
                               identifier: "str",
                               position: (260, 53),
                              },
                              Variable {
                               identifier: "path",
                               position: (260, 57),
                              },
                              Variable {
                               identifier: "package",
                               position: (260, 62),
                              },
                             ],
                             position: (260, 51),
                            },
                           ],
                          },
                          position: (260, 44),
                         },
                        ],
                       },
                       position: (260, 36),
                      },
                     ],
                    },
                    position: (260, 16),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "example",
                      position: (261, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PATH",
                         position: (261, 21),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "/foo/bar/bin",
                         position: (261, 29),
                        },
                       ],
                       position: (261, 28),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "LANG",
                         position: (261, 44),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "nl_NL.UTF-8",
                         position: (261, 52),
                        },
                       ],
                       position: (261, 51),
                      },
                     },
                    ],
                    recursive: false,
                    position: (261, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (262, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Environment variables passed to the service's processes.",
                      position: (262, 24),
                     },
                    ],
                    position: (262, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (258, 30),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (265, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (265, 14),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (266, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [],
                    position: (266, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (267, 9),
                     },
                    ],
                   },
                   to: With {
                    expression: Variable {
                     identifier: "types",
                     position: (267, 21),
                    },
                    target: FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (267, 28),
                     },
                     arguments: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "oneOf",
                         position: (267, 36),
                        },
                        arguments: [
                         List {
                          elements: [
                           Variable {
                            identifier: "package",
                            position: (267, 44),
                           },
                           Variable {
                            identifier: "str",
                            position: (267, 52),
                           },
                          ],
                          position: (267, 42),
                         },
                        ],
                       },
                       position: (267, 35),
                      },
                     ],
                    },
                    position: (267, 16),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (268, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Packages added to the service's <envar>PATH</envar>\nenvironment variable.  Both the <filename>bin</filename>\nand <filename>sbin</filename> subdirectories of each\npackage are added.\n",
                      position: (269, 1),
                     },
                    ],
                    position: (268, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (265, 23),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (276, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (276, 23),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (277, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [],
                    recursive: false,
                    position: (277, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "example",
                      position: (278, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "RestartSec",
                         position: (279, 13),
                        },
                       ],
                      },
                      to: Int {
                       value: 5,
                       position: (279, 26),
                      },
                     },
                    ],
                    recursive: false,
                    position: (279, 11),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (281, 9),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (281, 16),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "addCheck",
                        position: (281, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Parentheses {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (281, 32),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "attrsOf",
                           position: (281, 38),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "unitOption",
                         position: (281, 46),
                        },
                       ],
                      },
                      position: (281, 31),
                     },
                     Variable {
                      identifier: "checkService",
                      position: (281, 58),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (282, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Each attribute in this set specifies an option in the\n<literal>[Service]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.service</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                      position: (283, 1),
                     },
                    ],
                    position: (282, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (276, 32),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "script",
                 position: (290, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (290, 16),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (291, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (291, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (291, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (292, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (292, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (293, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed as the service's main process.",
                      position: (293, 24),
                     },
                    ],
                    position: (293, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (290, 25),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "scriptArgs",
                 position: (296, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (296, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (297, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (297, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (297, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (298, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (298, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (299, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Arguments passed to the main process script.",
                      position: (299, 24),
                     },
                    ],
                    position: (299, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (296, 29),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "preStart",
                 position: (302, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (302, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (303, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (303, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (303, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (304, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (304, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (305, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed before the service's main process\nis started.\n",
                      position: (306, 1),
                     },
                    ],
                    position: (305, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (302, 27),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "postStart",
                 position: (311, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (311, 19),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (312, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (312, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (312, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (313, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (313, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (314, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed after the service's main process\nis started.\n",
                      position: (315, 1),
                     },
                    ],
                    position: (314, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (311, 28),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "reload",
                 position: (320, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (320, 16),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (321, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (321, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (321, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (322, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (322, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (323, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed when the service's main process\nis reloaded.\n",
                      position: (324, 1),
                     },
                    ],
                    position: (323, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (320, 25),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "preStop",
                 position: (329, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (329, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (330, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (330, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (330, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (331, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (331, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (332, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed to stop the service.\n",
                      position: (333, 1),
                     },
                    ],
                    position: (332, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (329, 26),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "postStop",
                 position: (337, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (337, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (338, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (338, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lines",
                       position: (338, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (339, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [],
                    position: (339, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (340, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Shell commands executed after the service's main process\nhas exited.\n",
                      position: (341, 1),
                     },
                    ],
                    position: (340, 23),
                   },
                  },
                 ],
                 recursive: false,
                 position: (337, 27),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "jobScripts",
                 position: (346, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (346, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "type",
                      position: (347, 9),
                     },
                    ],
                   },
                   to: With {
                    expression: Variable {
                     identifier: "types",
                     position: (347, 21),
                    },
                    target: FunctionApplication {
                     function: Variable {
                      identifier: "coercedTo",
                      position: (347, 28),
                     },
                     arguments: [
                      Variable {
                       identifier: "path",
                       position: (347, 38),
                      },
                      Variable {
                       identifier: "singleton",
                       position: (347, 43),
                      },
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "listOf",
                         position: (347, 54),
                        },
                        arguments: [
                         Variable {
                          identifier: "path",
                          position: (347, 61),
                         },
                        ],
                       },
                       position: (347, 53),
                      },
                     ],
                    },
                    position: (347, 16),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "internal",
                      position: (348, 9),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (348, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (349, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "A list of all job script derivations of this unit.",
                      position: (349, 24),
                     },
                    ],
                    position: (349, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "default",
                      position: (350, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [],
                    position: (350, 19),
                   },
                  },
                 ],
                 recursive: false,
                 position: (346, 29),
                },
               ],
              },
             },
            ],
            recursive: false,
            position: (256, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "config",
              position: (355, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (355, 14),
            },
            arguments: [
             List {
              elements: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (356, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (356, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "preStart",
                         position: (356, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (356, 33),
                     },
                    ],
                    position: (356, 30),
                   },
                   position: (356, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (357, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "makeJobScript",
                       position: (357, 22),
                      },
                      arguments: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (357, 39),
                          },
                         },
                         Raw {
                          content: "-pre-start",
                          position: (357, 44),
                         },
                        ],
                        position: (357, 36),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (357, 56),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "preStart",
                           position: (357, 63),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (358, 9),
                       },
                       Raw {
                        content: "ExecStartPre",
                        position: (358, 23),
                       },
                      ],
                     },
                     to: List {
                      elements: [
                       Variable {
                        identifier: "jobScripts",
                        position: (358, 40),
                       },
                      ],
                      position: (358, 38),
                     },
                    },
                   ],
                   recursive: true,
                   position: (356, 37),
                  },
                 ],
                },
                position: (356, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (360, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (360, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "script",
                         position: (360, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (360, 31),
                     },
                    ],
                    position: (360, 28),
                   },
                   position: (360, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (361, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "makeJobScript",
                       position: (361, 22),
                      },
                      arguments: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (361, 39),
                          },
                         },
                         Raw {
                          content: "-start",
                          position: (361, 44),
                         },
                        ],
                        position: (361, 36),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (361, 52),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "script",
                           position: (361, 59),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (362, 9),
                       },
                       Raw {
                        content: "ExecStart",
                        position: (362, 23),
                       },
                      ],
                     },
                     to: BinaryOperation {
                      operator: Addition,
                      operands: [
                       BinaryOperation {
                        operator: Addition,
                        operands: [
                         Variable {
                          identifier: "jobScripts",
                          position: (362, 35),
                         },
                         String {
                          parts: [
                           Raw {
                            content: " ",
                            position: (362, 49),
                           },
                          ],
                          position: (362, 48),
                         },
                        ],
                        position: (362, 46),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (362, 54),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "scriptArgs",
                           position: (362, 61),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (362, 52),
                     },
                    },
                   ],
                   recursive: true,
                   position: (360, 35),
                  },
                 ],
                },
                position: (360, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (364, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (364, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "postStart",
                         position: (364, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (364, 34),
                     },
                    ],
                    position: (364, 31),
                   },
                   position: (364, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (365, 9),
                       },
                      ],
                     },
                     to: Parentheses {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "makeJobScript",
                        position: (365, 23),
                       },
                       arguments: [
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "name",
                            position: (365, 40),
                           },
                          },
                          Raw {
                           content: "-post-start",
                           position: (365, 45),
                          },
                         ],
                         position: (365, 37),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (365, 58),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "postStart",
                            position: (365, 65),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                      position: (365, 22),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (366, 9),
                       },
                       Raw {
                        content: "ExecStartPost",
                        position: (366, 23),
                       },
                      ],
                     },
                     to: List {
                      elements: [
                       Variable {
                        identifier: "jobScripts",
                        position: (366, 41),
                       },
                      ],
                      position: (366, 39),
                     },
                    },
                   ],
                   recursive: true,
                   position: (364, 38),
                  },
                 ],
                },
                position: (364, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (368, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (368, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "reload",
                         position: (368, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (368, 31),
                     },
                    ],
                    position: (368, 28),
                   },
                   position: (368, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (369, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "makeJobScript",
                       position: (369, 22),
                      },
                      arguments: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (369, 39),
                          },
                         },
                         Raw {
                          content: "-reload",
                          position: (369, 44),
                         },
                        ],
                        position: (369, 36),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (369, 53),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "reload",
                           position: (369, 60),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (370, 9),
                       },
                       Raw {
                        content: "ExecReload",
                        position: (370, 23),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "jobScripts",
                      position: (370, 36),
                     },
                    },
                   ],
                   recursive: true,
                   position: (368, 35),
                  },
                 ],
                },
                position: (368, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (372, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (372, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "preStop",
                         position: (372, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (372, 32),
                     },
                    ],
                    position: (372, 29),
                   },
                   position: (372, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (373, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "makeJobScript",
                       position: (373, 22),
                      },
                      arguments: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (373, 39),
                          },
                         },
                         Raw {
                          content: "-pre-stop",
                          position: (373, 44),
                         },
                        ],
                        position: (373, 36),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (373, 55),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "preStop",
                           position: (373, 62),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (374, 9),
                       },
                       Raw {
                        content: "ExecStop",
                        position: (374, 23),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "jobScripts",
                      position: (374, 34),
                     },
                    },
                   ],
                   recursive: true,
                   position: (372, 36),
                  },
                 ],
                },
                position: (372, 7),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (376, 8),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (376, 14),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "postStop",
                         position: (376, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                      position: (376, 33),
                     },
                    ],
                    position: (376, 30),
                   },
                   position: (376, 13),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "jobScripts",
                        position: (377, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "makeJobScript",
                       position: (377, 22),
                      },
                      arguments: [
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (377, 39),
                          },
                         },
                         Raw {
                          content: "-post-stop",
                          position: (377, 44),
                         },
                        ],
                        position: (377, 36),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (377, 56),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "postStop",
                           position: (377, 63),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "serviceConfig",
                        position: (378, 9),
                       },
                       Raw {
                        content: "ExecStopPost",
                        position: (378, 23),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "jobScripts",
                      position: (378, 38),
                     },
                    },
                   ],
                   recursive: true,
                   position: (376, 37),
                  },
                 ],
                },
                position: (376, 7),
               },
              ],
              position: (355, 22),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (255, 43),
        },
        position: (255, 20),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2ServiceOptions",
          position: (384, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (385, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (386, 7),
            },
            Variable {
             identifier: "serviceOptions",
             position: (387, 7),
            },
           ],
           position: (385, 15),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (390, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "restartIfChanged",
                position: (391, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (391, 26),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (392, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (392, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "bool",
                      position: (392, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (393, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (393, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (394, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Whether the service should be restarted during a NixOS\nconfiguration switch if its definition has changed.\n",
                     position: (395, 1),
                    },
                   ],
                   position: (394, 23),
                  },
                 },
                ],
                recursive: false,
                position: (391, 35),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "reloadIfChanged",
                position: (400, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (400, 25),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (401, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (401, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "bool",
                      position: (401, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (402, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "false",
                   position: (402, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (403, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Whether the service should be reloaded during a NixOS\nconfiguration switch if its definition has changed.  If\nenabled, the value of <option>restartIfChanged</option> is\nignored.\n\nThis option should not be used anymore in favor of\n<option>reloadTriggers</option> which allows more granular\ncontrol of when a service is reloaded and when a service\nis restarted.\n",
                     position: (404, 1),
                    },
                   ],
                   position: (403, 23),
                  },
                 },
                ],
                recursive: false,
                position: (400, 34),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "stopIfChanged",
                position: (416, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (416, 23),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (417, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (417, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "bool",
                      position: (417, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (418, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (418, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (419, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "If set, a changed unit is restarted by calling\n<command>systemctl stop</command> in the old configuration,\nthen <command>systemctl start</command> in the new one.\nOtherwise, it is restarted in a single step using\n<command>systemctl restart</command> in the new configuration.\nThe latter is less correct because it runs the\n<literal>ExecStop</literal> commands from the new\nconfiguration.\n",
                     position: (420, 1),
                    },
                   ],
                   position: (419, 23),
                  },
                 },
                ],
                recursive: false,
                position: (416, 32),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "startAt",
                position: (431, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (431, 17),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (432, 9),
                    },
                   ],
                  },
                  to: With {
                   expression: Variable {
                    identifier: "types",
                    position: (432, 21),
                   },
                   target: FunctionApplication {
                    function: Variable {
                     identifier: "either",
                     position: (432, 28),
                    },
                    arguments: [
                     Variable {
                      identifier: "str",
                      position: (432, 35),
                     },
                     Parentheses {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "listOf",
                        position: (432, 40),
                       },
                       arguments: [
                        Variable {
                         identifier: "str",
                         position: (432, 47),
                        },
                       ],
                      },
                      position: (432, 39),
                     },
                    ],
                   },
                   position: (432, 16),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (433, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [],
                   position: (433, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (434, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Sun 14:00:00",
                     position: (434, 20),
                    },
                   ],
                   position: (434, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (435, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Automatically start this unit at the given date/time, which\nmust be in the format described in\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry>.  This is equivalent\nto adding a corresponding timer unit with\n<option>OnCalendar</option> set to the value given here.\n",
                     position: (436, 1),
                    },
                   ],
                   position: (435, 23),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "apply",
                     position: (443, 9),
                    },
                   ],
                  },
                  to: Function {
                   argument: Simple {
                    identifier: "v",
                   },
                   definition: IfThenElse {
                    predicate: FunctionApplication {
                     function: Variable {
                      identifier: "isList",
                      position: (443, 23),
                     },
                     arguments: [
                      Variable {
                       identifier: "v",
                       position: (443, 30),
                      },
                     ],
                    },
                    then: Variable {
                     identifier: "v",
                     position: (443, 37),
                    },
                    else_: List {
                     elements: [
                      Variable {
                       identifier: "v",
                       position: (443, 46),
                      },
                     ],
                     position: (443, 44),
                    },
                    position: (443, 20),
                   },
                   position: (443, 17),
                  },
                 },
                ],
                recursive: false,
                position: (431, 26),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (390, 15),
          },
         },
        ],
        recursive: false,
        position: (384, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1ServiceOptions",
          position: (448, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (449, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (450, 7),
            },
            Variable {
             identifier: "serviceOptions",
             position: (451, 7),
            },
           ],
           position: (449, 15),
          },
         },
        ],
        recursive: false,
        position: (448, 26),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "socketOptions",
          position: (456, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (457, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "listenStreams",
                position: (459, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (459, 23),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (460, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [],
                   position: (460, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (461, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (461, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "listOf",
                       position: (461, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (461, 29),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "str",
                        position: (461, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (462, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "0.0.0.0:993",
                       position: (462, 22),
                      },
                     ],
                     position: (462, 21),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/my-socket",
                       position: (462, 36),
                      },
                     ],
                     position: (462, 35),
                    },
                   ],
                   position: (462, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (463, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "For each item in this list, a <literal>ListenStream</literal>\noption in the <literal>[Socket]</literal> section will be created.\n",
                     position: (464, 1),
                    },
                   ],
                   position: (463, 23),
                  },
                 },
                ],
                recursive: false,
                position: (459, 32),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "listenDatagrams",
                position: (469, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (469, 25),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (470, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [],
                   position: (470, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (471, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (471, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "listOf",
                       position: (471, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (471, 29),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "str",
                        position: (471, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (472, 9),
                    },
                   ],
                  },
                  to: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "0.0.0.0:993",
                       position: (472, 22),
                      },
                     ],
                     position: (472, 21),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/my-socket",
                       position: (472, 36),
                      },
                     ],
                     position: (472, 35),
                    },
                   ],
                   position: (472, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (473, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "For each item in this list, a <literal>ListenDatagram</literal>\noption in the <literal>[Socket]</literal> section will be created.\n",
                     position: (474, 1),
                    },
                   ],
                   position: (473, 23),
                  },
                 },
                ],
                recursive: false,
                position: (469, 34),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "socketConfig",
                position: (479, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (479, 22),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (480, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (480, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (481, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "ListenStream",
                        position: (481, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "/run/my-socket",
                        position: (481, 37),
                       },
                      ],
                      position: (481, 36),
                     },
                    },
                   ],
                   recursive: false,
                   position: (481, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (482, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (482, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (482, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (482, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (483, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Socket]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.socket</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                     position: (484, 1),
                    },
                   ],
                   position: (483, 23),
                  },
                 },
                ],
                recursive: false,
                position: (479, 31),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (457, 15),
          },
         },
        ],
        recursive: false,
        position: (456, 19),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2SocketOptions",
          position: (494, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (495, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (496, 7),
            },
            Variable {
             identifier: "socketOptions",
             position: (497, 7),
            },
           ],
           position: (495, 15),
          },
         },
        ],
        recursive: false,
        position: (494, 25),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1SocketOptions",
          position: (501, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (502, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (503, 7),
            },
            Variable {
             identifier: "socketOptions",
             position: (504, 7),
            },
           ],
           position: (502, 15),
          },
         },
        ],
        recursive: false,
        position: (501, 25),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "timerOptions",
          position: (509, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (510, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "timerConfig",
                position: (512, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (512, 21),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (513, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (513, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (514, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "OnCalendar",
                        position: (514, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "Sun 14:00:00",
                        position: (514, 35),
                       },
                      ],
                      position: (514, 34),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "Unit",
                        position: (514, 50),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "foo.service",
                        position: (514, 58),
                       },
                      ],
                      position: (514, 57),
                     },
                    },
                   ],
                   recursive: false,
                   position: (514, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (515, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (515, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (515, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (515, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (516, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Timer]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.timer</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> and\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry> for details.\n",
                     position: (517, 1),
                    },
                   ],
                   position: (516, 23),
                  },
                 },
                ],
                recursive: false,
                position: (512, 30),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (510, 15),
          },
         },
        ],
        recursive: false,
        position: (509, 18),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2TimerOptions",
          position: (529, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (530, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (531, 7),
            },
            Variable {
             identifier: "timerOptions",
             position: (532, 7),
            },
           ],
           position: (530, 15),
          },
         },
        ],
        recursive: false,
        position: (529, 24),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1TimerOptions",
          position: (536, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (537, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (538, 7),
            },
            Variable {
             identifier: "timerOptions",
             position: (539, 7),
            },
           ],
           position: (537, 15),
          },
         },
        ],
        recursive: false,
        position: (536, 24),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "pathOptions",
          position: (544, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (545, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "pathConfig",
                position: (547, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (547, 20),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (548, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (548, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (549, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "PathChanged",
                        position: (549, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "/some/path",
                        position: (549, 36),
                       },
                      ],
                      position: (549, 35),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "Unit",
                        position: (549, 49),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "changedpath.service",
                        position: (549, 57),
                       },
                      ],
                      position: (549, 56),
                     },
                    },
                   ],
                   recursive: false,
                   position: (549, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (550, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (550, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (550, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (550, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (551, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Path]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.path</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                     position: (552, 1),
                    },
                   ],
                   position: (551, 23),
                  },
                 },
                ],
                recursive: false,
                position: (547, 29),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (545, 15),
          },
         },
        ],
        recursive: false,
        position: (544, 17),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2PathOptions",
          position: (562, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (563, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (564, 7),
            },
            Variable {
             identifier: "pathOptions",
             position: (565, 7),
            },
           ],
           position: (563, 15),
          },
         },
        ],
        recursive: false,
        position: (562, 23),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1PathOptions",
          position: (569, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (570, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (571, 7),
            },
            Variable {
             identifier: "pathOptions",
             position: (572, 7),
            },
           ],
           position: (570, 15),
          },
         },
        ],
        recursive: false,
        position: (569, 23),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "mountOptions",
          position: (577, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (578, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "what",
                position: (580, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (580, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (581, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "/dev/sda1",
                     position: (581, 20),
                    },
                   ],
                   position: (581, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (582, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (582, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "str",
                      position: (582, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (583, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Absolute path of device node, file or other resource. (Mandatory)",
                     position: (583, 24),
                    },
                   ],
                   position: (583, 23),
                  },
                 },
                ],
                recursive: false,
                position: (580, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "where",
                position: (586, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (586, 15),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (587, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "/mnt",
                     position: (587, 20),
                    },
                   ],
                   position: (587, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (588, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (588, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "str",
                      position: (588, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (589, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Absolute path of a directory of the mount point.\nWill be created if it doesn't exist. (Mandatory)\n",
                     position: (590, 1),
                    },
                   ],
                   position: (589, 23),
                  },
                 },
                ],
                recursive: false,
                position: (586, 24),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (595, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (595, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (596, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [],
                   position: (596, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (597, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "ext4",
                     position: (597, 20),
                    },
                   ],
                   position: (597, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (598, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (598, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "str",
                      position: (598, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (599, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "File system type.",
                     position: (599, 24),
                    },
                   ],
                   position: (599, 23),
                  },
                 },
                ],
                recursive: false,
                position: (595, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (602, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (602, 17),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (603, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [],
                   position: (603, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (604, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "noatime",
                     position: (604, 20),
                    },
                   ],
                   position: (604, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (605, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (605, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "commas",
                      position: (605, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (606, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Options used to mount the file system.",
                     position: (606, 24),
                    },
                   ],
                   position: (606, 23),
                  },
                 },
                ],
                recursive: false,
                position: (602, 26),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "mountConfig",
                position: (609, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (609, 21),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (610, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (610, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (611, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "DirectoryMode",
                        position: (611, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "0775",
                        position: (611, 38),
                       },
                      ],
                      position: (611, 37),
                     },
                    },
                   ],
                   recursive: false,
                   position: (611, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (612, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (612, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (612, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (612, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (613, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Mount]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.mount</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                     position: (614, 1),
                    },
                   ],
                   position: (613, 23),
                  },
                 },
                ],
                recursive: false,
                position: (609, 30),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (578, 15),
          },
         },
        ],
        recursive: false,
        position: (577, 18),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2MountOptions",
          position: (624, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (625, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (626, 7),
            },
            Variable {
             identifier: "mountOptions",
             position: (627, 7),
            },
           ],
           position: (625, 15),
          },
         },
        ],
        recursive: false,
        position: (624, 24),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1MountOptions",
          position: (631, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (632, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (633, 7),
            },
            Variable {
             identifier: "mountOptions",
             position: (634, 7),
            },
           ],
           position: (632, 15),
          },
         },
        ],
        recursive: false,
        position: (631, 24),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "automountOptions",
          position: (638, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (639, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "where",
                position: (641, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (641, 15),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (642, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "/mnt",
                     position: (642, 20),
                    },
                   ],
                   position: (642, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (643, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (643, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "str",
                      position: (643, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (644, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Absolute path of a directory of the mount point.\nWill be created if it doesn't exist. (Mandatory)\n",
                     position: (645, 1),
                    },
                   ],
                   position: (644, 23),
                  },
                 },
                ],
                recursive: false,
                position: (641, 24),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "automountConfig",
                position: (650, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (650, 25),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (651, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (651, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (652, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "DirectoryMode",
                        position: (652, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "0775",
                        position: (652, 38),
                       },
                      ],
                      position: (652, 37),
                     },
                    },
                   ],
                   recursive: false,
                   position: (652, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (653, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (653, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (653, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (653, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (654, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Automount]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.automount</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                     position: (655, 1),
                    },
                   ],
                   position: (654, 23),
                  },
                 },
                ],
                recursive: false,
                position: (650, 34),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (639, 15),
          },
         },
        ],
        recursive: false,
        position: (638, 22),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2AutomountOptions",
          position: (665, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (666, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (667, 7),
            },
            Variable {
             identifier: "automountOptions",
             position: (668, 7),
            },
           ],
           position: (666, 15),
          },
         },
        ],
        recursive: false,
        position: (665, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1AutomountOptions",
          position: (672, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (673, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (674, 7),
            },
            Variable {
             identifier: "automountOptions",
             position: (675, 7),
            },
           ],
           position: (673, 15),
          },
         },
        ],
        recursive: false,
        position: (672, 28),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "sliceOptions",
          position: (679, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "options",
             position: (680, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "sliceConfig",
                position: (682, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (682, 21),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (683, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [],
                   recursive: false,
                   position: (683, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (684, 9),
                    },
                   ],
                  },
                  to: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "MemoryMax",
                        position: (684, 21),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "2G",
                        position: (684, 34),
                       },
                      ],
                      position: (684, 33),
                     },
                    },
                   ],
                   recursive: false,
                   position: (684, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (685, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (685, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "attrsOf",
                       position: (685, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "unitOption",
                     position: (685, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (686, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Each attribute in this set specifies an option in the\n<literal>[Slice]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.slice</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                     position: (687, 1),
                    },
                   ],
                   position: (686, 23),
                  },
                 },
                ],
                recursive: false,
                position: (682, 30),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (680, 15),
          },
         },
        ],
        recursive: false,
        position: (679, 18),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage2SliceOptions",
          position: (697, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (698, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage2CommonUnitOptions",
             position: (699, 7),
            },
            Variable {
             identifier: "sliceOptions",
             position: (700, 7),
            },
           ],
           position: (698, 15),
          },
         },
        ],
        recursive: false,
        position: (697, 24),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "stage1SliceOptions",
          position: (704, 3),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (705, 5),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "stage1CommonUnitOptions",
             position: (706, 7),
            },
            Variable {
             identifier: "sliceOptions",
             position: (707, 7),
            },
           ],
           position: (705, 15),
          },
         },
        ],
        recursive: false,
        position: (704, 24),
       },
      },
     ],
     recursive: true,
     position: (16, 4),
    },
    position: (6, 1),
   },
   position: (4, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}