---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "postfix",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "user",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (8, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "user",
         position: (8, 14),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "group",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (9, 11),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "group",
         position: (9, 15),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "setgidGroup",
        position: (10, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (10, 17),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "setgidGroup",
         position: (10, 21),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "haveAliases",
        position: (12, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalOr,
      operands: [
       BinaryOperation {
        operator: LogicalOr,
        operands: [
         BinaryOperation {
          operator: NotEqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (12, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "postmasterAlias",
               position: (12, 21),
              },
             ],
            },
            default: None,
           },
           String {
            parts: [],
           },
          ],
          position: (12, 37),
         },
         BinaryOperation {
          operator: NotEqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (12, 46),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "rootAlias",
               position: (12, 50),
              },
             ],
            },
            default: None,
           },
           String {
            parts: [],
           },
          ],
          position: (12, 60),
         },
        ],
        position: (12, 43),
       },
       BinaryOperation {
        operator: NotEqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (13, 26),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "extraAliases",
             position: (13, 30),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [],
         },
        ],
        position: (13, 43),
       },
      ],
      position: (13, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "haveCanonical",
        position: (14, 3),
       },
      ],
     },
     BinaryOperation {
      operator: NotEqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (14, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "canonical",
           position: (14, 23),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [],
       },
      ],
      position: (14, 33),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "haveTransport",
        position: (15, 3),
       },
      ],
     },
     BinaryOperation {
      operator: NotEqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (15, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "transport",
           position: (15, 23),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [],
       },
      ],
      position: (15, 33),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "haveVirtual",
        position: (16, 3),
       },
      ],
     },
     BinaryOperation {
      operator: NotEqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (16, 17),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "virtual",
           position: (16, 21),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [],
       },
      ],
      position: (16, 29),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "haveLocalRecipients",
        position: (17, 3),
       },
      ],
     },
     BinaryOperation {
      operator: NotEqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (17, 25),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "localRecipients",
           position: (17, 29),
          },
         ],
        },
        default: None,
       },
       Variable {
        identifier: "null",
        position: (17, 48),
       },
      ],
      position: (17, 45),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "clientAccess",
        position: (19, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "optional",
       position: (20, 5),
      },
      arguments: [
       BinaryOperation {
        operator: NotEqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (20, 15),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "dnsBlacklistOverrides",
             position: (20, 19),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [],
         },
        ],
        position: (20, 41),
       },
       String {
        parts: [
         Raw {
          content: "check_client_access hash:/etc/postfix/client_access",
          position: (21, 8),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dnsBl",
        position: (23, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "optionals",
       position: (24, 5),
      },
      arguments: [
       BinaryOperation {
        operator: NotEqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (24, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "dnsBlacklists",
             position: (24, 20),
            },
           ],
          },
          default: None,
         },
         List {
          elements: [],
          position: (24, 37),
         },
        ],
        position: (24, 34),
       },
       FunctionApplication {
        function: Variable {
         identifier: "map",
         position: (25, 8),
        },
        arguments: [
         Function {
          argument: Some(
           "s",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: BinaryOperation {
           operator: Addition,
           operands: [
            String {
             parts: [
              Raw {
               content: "reject_rbl_client ",
               position: (25, 17),
              },
             ],
            },
            Variable {
             identifier: "s",
             position: (25, 39),
            },
           ],
           position: (25, 37),
          },
          position: (25, 13),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (25, 42),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "dnsBlacklists",
             position: (25, 46),
            },
           ],
          },
          default: None,
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "clientRestrictions",
        position: (27, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (27, 24),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: ", ",
          position: (27, 42),
         },
        ],
       },
       BinaryOperation {
        operator: Concatenation,
        operands: [
         Variable {
          identifier: "clientAccess",
          position: (27, 47),
         },
         Variable {
          identifier: "dnsBl",
          position: (27, 63),
         },
        ],
        position: (27, 60),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mainCf",
        position: (29, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "escape",
           position: (30, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "replaceStrings",
          position: (30, 14),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "$",
               position: (30, 31),
              },
             ],
            },
           ],
           position: (30, 29),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "$$",
               position: (30, 37),
              },
             ],
            },
           ],
           position: (30, 35),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mkList",
           position: (31, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "items",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: Addition,
          operands: [
           String {
            parts: [
             Raw {
              content: "\n  ",
              position: (31, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "concatStringsSep",
             position: (31, 30),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: ",\n  ",
                position: (31, 48),
               },
              ],
             },
             Variable {
              identifier: "items",
              position: (31, 55),
             },
            ],
           },
          ],
          position: (31, 28),
         },
         position: (31, 14),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mkVal",
           position: (32, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "value",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: IfThenElse {
          predicate: FunctionApplication {
           function: Variable {
            identifier: "isList",
            position: (33, 10),
           },
           arguments: [
            Variable {
             identifier: "value",
             position: (33, 17),
            },
           ],
          },
          then: FunctionApplication {
           function: Variable {
            identifier: "mkList",
            position: (33, 28),
           },
           arguments: [
            Variable {
             identifier: "value",
             position: (33, 35),
            },
           ],
          },
          else_: BinaryOperation {
           operator: Addition,
           operands: [
            String {
             parts: [
              Raw {
               content: " ",
               position: (34, 15),
              },
             ],
            },
            IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "value",
                position: (34, 24),
               },
               Variable {
                identifier: "true",
                position: (34, 33),
               },
              ],
              position: (34, 30),
             },
             then: String {
              parts: [
               Raw {
                content: "yes",
                position: (34, 44),
               },
              ],
             },
             else_: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "value",
                 position: (35, 17),
                },
                Variable {
                 identifier: "false",
                 position: (35, 26),
                },
               ],
               position: (35, 23),
              },
              then: String {
               parts: [
                Raw {
                 content: "no",
                 position: (35, 38),
                },
               ],
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (36, 14),
               },
               arguments: [
                Variable {
                 identifier: "value",
                 position: (36, 23),
                },
               ],
              },
              position: (35, 14),
             },
             position: (34, 21),
            },
           ],
           position: (34, 18),
          },
          position: (33, 7),
         },
         position: (32, 13),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "mkEntry",
           position: (37, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "name",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "value",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: String {
           parts: [
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "escape",
               position: (37, 31),
              },
              arguments: [
               Variable {
                identifier: "name",
                position: (37, 38),
               },
              ],
             },
            },
            Raw {
             content: " =",
             position: (37, 43),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "mkVal",
               position: (37, 47),
              },
              arguments: [
               Variable {
                identifier: "value",
                position: (37, 53),
               },
              ],
             },
            },
           ],
          },
          position: (37, 21),
         },
         position: (37, 15),
        },
       ),
      ],
      target: BinaryOperation {
       operator: Addition,
       operands: [
        BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (39, 5),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (39, 23),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (39, 28),
             },
             arguments: [
              Variable {
               identifier: "mkEntry",
               position: (39, 43),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (39, 51),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (39, 55),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "\n",
             position: (40, 10),
            },
           ],
          },
         ],
         position: (40, 7),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (40, 16),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "extraConfig",
            position: (40, 20),
           },
          ],
         },
         default: None,
        },
       ],
       position: (40, 14),
      },
      position: (29, 12),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "masterCfOptions",
        position: (42, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "name",
         default: None,
        },
        FunctionArgument {
         identifier: "config",
         default: None,
        },
        FunctionArgument {
         identifier: "options",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (43, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (44, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (44, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (45, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (45, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (45, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (46, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "name",
                  position: (46, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (47, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "smtp",
                    position: (47, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (48, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The name of the service to run. Defaults to the attribute set key.\n",
                    position: (49, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (44, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (53, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (53, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (54, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (54, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (54, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "inet",
                        position: (54, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "unix",
                        position: (54, 37),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "unix-dgram",
                        position: (54, 44),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "fifo",
                        position: (54, 57),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "pass",
                        position: (54, 64),
                       },
                      ],
                     },
                    ],
                    position: (54, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (55, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "unix",
                    position: (55, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (56, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "inet",
                    position: (56, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (57, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The type of the service",
                    position: (57, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (53, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "private",
               position: (60, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (60, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (61, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (61, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (61, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (62, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (62, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (63, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether the service's sockets and storage directory is restricted to\nbe only available via the mail system. If <literal>null</literal> is\ngiven it uses the postfix default <literal>true</literal>.\n",
                    position: (64, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (60, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "privileged",
               position: (70, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (70, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (71, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (71, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (71, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (72, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (72, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (73, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
               ],
               recursive: false,
               position: (70, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "chroot",
               position: (76, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (76, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (77, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (77, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (77, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (78, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (78, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (79, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether the service is chrooted to have only access to the\n<option>services.postfix.queueDir</option> and the closure of\nstore paths specified by the <option>program</option> option.\n",
                    position: (80, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (76, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wakeup",
               position: (86, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (86, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (87, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (87, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (87, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (88, 9),
                   },
                  ],
                 },
                 Int {
                  value: 60,
                  position: (88, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (89, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Automatically wake up the service after the specified number of\nseconds. If <literal>0</literal> is given, never wake the service\nup.\n",
                    position: (90, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (86, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wakeupUnusedComponent",
               position: (96, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (96, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (97, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (97, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (97, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (98, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (98, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (99, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If set to <literal>false</literal> the component will only be woken\nup if it is used. This is equivalent to postfix' notion of adding a\nquestion mark behind the wakeup time in\n<filename>master.cf</filename>\n",
                    position: (100, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (96, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "maxproc",
               position: (107, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (107, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (108, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (108, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (108, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (109, 9),
                   },
                  ],
                 },
                 Int {
                  value: 1,
                  position: (109, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (110, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The maximum number of processes to spawn for this service. If the\nvalue is <literal>0</literal> it doesn't have any limit. If\n<literal>null</literal> is given it uses the postfix default of\n<literal>100</literal>.\n",
                    position: (111, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (107, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "command",
               position: (118, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (118, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (119, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (119, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (119, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (120, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "name",
                  position: (120, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (121, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "smtpd",
                    position: (121, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (122, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A program name specifying a Postfix service/daemon process.\nBy default it's the attribute <option>name</option>.\n",
                    position: (123, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (118, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "args",
               position: (128, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (128, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (129, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (129, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (129, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (129, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (129, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (130, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (130, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (131, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "-o",
                      position: (131, 22),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "smtp_helo_timeout=5",
                      position: (131, 27),
                     },
                    ],
                   },
                  ],
                  position: (131, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (132, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Arguments to pass to the <option>command</option>. There is no shell\nprocessing involved and shell syntax is passed verbatim to the\nprocess.\n",
                    position: (133, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (128, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rawEntry",
               position: (139, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (139, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (140, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (140, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (140, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (140, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (140, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (141, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (141, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (142, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (142, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (143, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The raw configuration line for the <filename>master.cf</filename>.\n",
                    position: (144, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (139, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (43, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (149, 5),
           },
           Raw {
            content: "rawEntry",
            position: (149, 12),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mkBool",
               position: (150, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "bool",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: IfThenElse {
              predicate: Variable {
               identifier: "bool",
               position: (150, 25),
              },
              then: String {
               parts: [
                Raw {
                 content: "y",
                 position: (150, 36),
                },
               ],
              },
              else_: String {
               parts: [
                Raw {
                 content: "n",
                 position: (150, 45),
                },
               ],
              },
              position: (150, 22),
             },
             position: (150, 16),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mkArg",
               position: (151, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "arg",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: String {
              parts: [
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (151, 23),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "hasPrefix",
                    position: (151, 39),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "-",
                       position: (151, 50),
                      },
                     ],
                    },
                    Variable {
                     identifier: "arg",
                     position: (151, 53),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "\n  ",
                     position: (151, 59),
                    },
                   ],
                  },
                 ],
                },
               },
               Expression {
                expression: Variable {
                 identifier: "arg",
                 position: (151, 67),
                },
               },
              ],
             },
             position: (151, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "maybeOption",
               position: (153, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "fun",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "option",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: IfThenElse {
               predicate: PropertyAccess {
                expression: Variable {
                 identifier: "options",
                 position: (154, 12),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "option",
                    position: (154, 22),
                   },
                  },
                  Raw {
                   content: "isDefined",
                   position: (154, 30),
                  },
                 ],
                },
                default: None,
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "fun",
                 position: (154, 45),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (154, 49),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Expression {
                     expression: Variable {
                      identifier: "option",
                      position: (154, 58),
                     },
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               else_: String {
                parts: [
                 Raw {
                  content: "-",
                  position: (154, 72),
                 },
                ],
               },
               position: (154, 9),
              },
              position: (153, 26),
             },
             position: (153, 21),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wakeup",
               position: (157, 7),
              },
             ],
            },
            LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wakeupDefined",
                  position: (158, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "options",
                 position: (158, 25),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "wakeup",
                   position: (158, 33),
                  },
                  Raw {
                   content: "isDefined",
                   position: (158, 40),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wakeupUCDefined",
                  position: (159, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "options",
                 position: (159, 27),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "wakeupUnusedComponent",
                   position: (159, 35),
                  },
                  Raw {
                   content: "isDefined",
                   position: (159, 57),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "finalValue",
                  position: (160, 9),
                 },
                ],
               },
               BinaryOperation {
                operator: Addition,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (160, 22),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (160, 31),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "wakeup",
                       position: (160, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (161, 22),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     Variable {
                      identifier: "wakeupUCDefined",
                      position: (161, 38),
                     },
                     UnaryOperation {
                      operator: Not,
                      operand: PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (161, 58),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeupUnusedComponent",
                          position: (161, 65),
                         },
                        ],
                       },
                       default: None,
                      },
                      position: (161, 57),
                     },
                    ],
                    position: (161, 54),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "?",
                      position: (161, 89),
                     },
                    ],
                   },
                  ],
                 },
                ],
                position: (161, 20),
               },
              ),
             ],
             target: IfThenElse {
              predicate: Variable {
               identifier: "wakeupDefined",
               position: (162, 13),
              },
              then: Variable {
               identifier: "finalValue",
               position: (162, 32),
              },
              else_: String {
               parts: [
                Raw {
                 content: "-",
                 position: (162, 49),
                },
               ],
              },
              position: (162, 10),
             },
             position: (157, 16),
            },
           ),
          ],
          target: List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (165, 7),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (165, 14),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (166, 7),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (166, 14),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "maybeOption",
              position: (167, 8),
             },
             arguments: [
              Variable {
               identifier: "mkBool",
               position: (167, 20),
              },
              String {
               parts: [
                Raw {
                 content: "private",
                 position: (167, 28),
                },
               ],
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "maybeOption",
              position: (168, 8),
             },
             arguments: [
              Function {
               argument: Some(
                "b",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "mkBool",
                 position: (168, 24),
                },
                arguments: [
                 UnaryOperation {
                  operator: Not,
                  operand: Variable {
                   identifier: "b",
                   position: (168, 33),
                  },
                  position: (168, 32),
                 },
                ],
               },
               position: (168, 21),
              },
              String {
               parts: [
                Raw {
                 content: "privileged",
                 position: (168, 38),
                },
               ],
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "maybeOption",
              position: (169, 8),
             },
             arguments: [
              Variable {
               identifier: "mkBool",
               position: (169, 20),
              },
              String {
               parts: [
                Raw {
                 content: "chroot",
                 position: (169, 28),
                },
               ],
              },
             ],
            },
            Variable {
             identifier: "wakeup",
             position: (170, 7),
            },
            FunctionApplication {
             function: Variable {
              identifier: "maybeOption",
              position: (171, 8),
             },
             arguments: [
              Variable {
               identifier: "toString",
               position: (171, 20),
              },
              String {
               parts: [
                Raw {
                 content: "maxproc",
                 position: (171, 30),
                },
               ],
              },
             ],
            },
            BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (172, 8),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "command",
                    position: (172, 15),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: " ",
                   position: (172, 26),
                  },
                 ],
                },
               ],
               position: (172, 23),
              },
              FunctionApplication {
               function: Variable {
                identifier: "concatMapStringsSep",
                position: (172, 31),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: " ",
                   position: (172, 52),
                  },
                 ],
                },
                Variable {
                 identifier: "mkArg",
                 position: (172, 55),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (172, 61),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "args",
                    position: (172, 68),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
             position: (172, 29),
            },
           ],
           position: (164, 8),
          },
          position: (149, 23),
         },
        ),
       ],
       recursive: false,
       position: (42, 53),
      },
      position: (42, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "masterCfContent",
        position: (176, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "labels",
           position: (178, 5),
          },
         ],
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "# service",
             position: (179, 8),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "type",
             position: (179, 20),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "private",
             position: (179, 27),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "unpriv",
             position: (179, 37),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "chroot",
             position: (179, 46),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "wakeup",
             position: (179, 55),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "maxproc",
             position: (179, 64),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "command + args",
             position: (180, 8),
            },
           ],
          },
         ],
         position: (178, 14),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "labelDefaults",
           position: (183, 5),
          },
         ],
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "# ",
             position: (184, 8),
            },
           ],
          },
          String {
           parts: [],
          },
          String {
           parts: [
            Raw {
             content: "(yes)",
             position: (184, 16),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "(yes)",
             position: (184, 24),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "(no)",
             position: (184, 32),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "(never)",
             position: (184, 39),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "(100)",
             position: (184, 49),
            },
           ],
          },
          String {
           parts: [],
          },
          String {
           parts: [],
          },
         ],
         position: (183, 21),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "masterCf",
           position: (187, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (187, 16),
         },
         arguments: [
          FunctionApplication {
           function: Variable {
            identifier: "const",
            position: (187, 32),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "getAttr",
              position: (187, 39),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "rawEntry",
                 position: (187, 48),
                },
               ],
              },
             ],
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (187, 60),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "masterConfig",
              position: (187, 64),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "maxWidths",
           position: (190, 5),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "foldLine",
              position: (191, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "line",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "acc",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "columnLengths",
                   position: (192, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (192, 25),
                 },
                 arguments: [
                  Variable {
                   identifier: "stringLength",
                   position: (192, 29),
                  },
                  Variable {
                   identifier: "line",
                   position: (192, 42),
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "zipListsWith",
                position: (193, 10),
               },
               arguments: [
                Variable {
                 identifier: "max",
                 position: (193, 23),
                },
                Variable {
                 identifier: "acc",
                 position: (193, 27),
                },
                Variable {
                 identifier: "columnLengths",
                 position: (193, 31),
                },
               ],
              },
              position: (191, 29),
             },
             position: (191, 24),
            },
            position: (191, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "lines",
              position: (196, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               Variable {
                identifier: "labels",
                position: (196, 17),
               },
               Variable {
                identifier: "labelDefaults",
                position: (196, 24),
               },
              ],
              position: (196, 15),
             },
             FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (196, 44),
              },
              arguments: [
               Function {
                argument: Some(
                 "l",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "init",
                    position: (196, 52),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (196, 57),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [],
                    },
                   ],
                   position: (196, 62),
                  },
                 ],
                 position: (196, 59),
                },
                position: (196, 49),
               },
               Variable {
                identifier: "masterCf",
                position: (196, 68),
               },
              ],
             },
            ],
            position: (196, 40),
           },
          ),
         ],
         target: FunctionApplication {
          function: Variable {
           identifier: "foldr",
           position: (197, 8),
          },
          arguments: [
           Variable {
            identifier: "foldLine",
            position: (197, 14),
           },
           FunctionApplication {
            function: Variable {
             identifier: "genList",
             position: (197, 24),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "const",
               position: (197, 33),
              },
              arguments: [
               Int {
                value: 0,
                position: (197, 39),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "length",
               position: (197, 43),
              },
              arguments: [
               Variable {
                identifier: "labels",
                position: (197, 50),
               },
              ],
             },
            ],
           },
           Variable {
            identifier: "lines",
            position: (197, 59),
           },
          ],
         },
         position: (190, 17),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "pad",
           position: (200, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "width",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "str",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "padWidth",
                position: (201, 7),
               },
              ],
             },
             BinaryOperation {
              operator: Subtraction,
              operands: [
               Variable {
                identifier: "width",
                position: (201, 18),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "stringLength",
                 position: (201, 26),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (201, 39),
                 },
                ],
               },
              ],
              position: (201, 24),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "padding",
                position: (202, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "concatStrings",
               position: (202, 17),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "genList",
                 position: (202, 32),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "const",
                   position: (202, 41),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: " ",
                      position: (202, 48),
                     },
                    ],
                   },
                  ],
                 },
                 Variable {
                  identifier: "padWidth",
                  position: (202, 52),
                 },
                ],
               },
              ],
             },
            ),
           ],
           target: BinaryOperation {
            operator: Addition,
            operands: [
             Variable {
              identifier: "str",
              position: (203, 8),
             },
             FunctionApplication {
              function: Variable {
               identifier: "optionalString",
               position: (203, 14),
              },
              arguments: [
               BinaryOperation {
                operator: GreaterThan,
                operands: [
                 Variable {
                  identifier: "padWidth",
                  position: (203, 30),
                 },
                 Int {
                  value: 0,
                  position: (203, 41),
                 },
                ],
                position: (203, 39),
               },
               Variable {
                identifier: "padding",
                position: (203, 44),
               },
              ],
             },
            ],
            position: (203, 12),
           },
           position: (200, 23),
          },
          position: (200, 18),
         },
         position: (200, 11),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "fullWidth",
           position: (206, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "foldr",
          position: (206, 17),
         },
         arguments: [
          Function {
           argument: Some(
            "width",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "acc",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                Variable {
                 identifier: "acc",
                 position: (206, 36),
                },
                Variable {
                 identifier: "width",
                 position: (206, 42),
                },
               ],
               position: (206, 40),
              },
              Int {
               value: 2,
               position: (206, 50),
              },
             ],
             position: (206, 48),
            },
            position: (206, 31),
           },
           position: (206, 24),
          },
          Int {
           value: 0,
           position: (206, 53),
          },
          Variable {
           identifier: "maxWidths",
           position: (206, 55),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "formatLine",
           position: (208, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "line",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: FunctionApplication {
          function: Variable {
           identifier: "concatStringsSep",
           position: (208, 24),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "  ",
              position: (208, 42),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "zipListsWith",
             position: (208, 47),
            },
            arguments: [
             Variable {
              identifier: "pad",
              position: (208, 60),
             },
             Variable {
              identifier: "maxWidths",
              position: (208, 64),
             },
             Variable {
              identifier: "line",
              position: (208, 74),
             },
            ],
           },
          ],
         },
         position: (208, 18),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "formattedLabels",
           position: (210, 5),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "sep",
              position: (211, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Addition,
            operands: [
             String {
              parts: [
               Raw {
                content: "# ",
                position: (211, 14),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "concatStrings",
               position: (211, 20),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "genList",
                 position: (211, 35),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "const",
                   position: (211, 44),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "=",
                      position: (211, 51),
                     },
                    ],
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   Variable {
                    identifier: "fullWidth",
                    position: (211, 56),
                   },
                   Int {
                    value: 5,
                    position: (211, 68),
                   },
                  ],
                  position: (211, 66),
                 },
                ],
               },
              ],
             },
            ],
            position: (211, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "lines",
              position: (212, 7),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "sep",
              position: (212, 17),
             },
             FunctionApplication {
              function: Variable {
               identifier: "formatLine",
               position: (212, 22),
              },
              arguments: [
               Variable {
                identifier: "labels",
                position: (212, 33),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "formatLine",
               position: (212, 42),
              },
              arguments: [
               Variable {
                identifier: "labelDefaults",
                position: (212, 53),
               },
              ],
             },
             Variable {
              identifier: "sep",
              position: (212, 68),
             },
            ],
            position: (212, 15),
           },
          ),
         ],
         target: FunctionApplication {
          function: Variable {
           identifier: "concatStringsSep",
           position: (213, 8),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "\n",
              position: (213, 26),
             },
            ],
           },
           Variable {
            identifier: "lines",
            position: (213, 30),
           },
          ],
         },
         position: (210, 23),
        },
       ),
      ],
      target: BinaryOperation {
       operator: Addition,
       operands: [
        BinaryOperation {
         operator: Addition,
         operands: [
          BinaryOperation {
           operator: Addition,
           operands: [
            BinaryOperation {
             operator: Addition,
             operands: [
              Variable {
               identifier: "formattedLabels",
               position: (215, 6),
              },
              String {
               parts: [
                Raw {
                 content: "\n",
                 position: (215, 25),
                },
               ],
              },
             ],
             position: (215, 22),
            },
            FunctionApplication {
             function: Variable {
              identifier: "concatMapStringsSep",
              position: (215, 31),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "\n",
                 position: (215, 52),
                },
               ],
              },
              Variable {
               identifier: "formatLine",
               position: (215, 56),
              },
              Variable {
               identifier: "masterCf",
               position: (215, 67),
              },
             ],
            },
           ],
           position: (215, 29),
          },
          String {
           parts: [
            Raw {
             content: "\n",
             position: (215, 79),
            },
           ],
          },
         ],
         position: (215, 76),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (215, 85),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "extraMasterConf",
            position: (215, 89),
           },
          ],
         },
         default: None,
        },
       ],
       position: (215, 83),
      },
      position: (176, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "headerCheckOptions",
        position: (217, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (219, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pattern",
               position: (220, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (220, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (221, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (221, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (221, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (222, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/^.*/",
                    position: (222, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (223, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/^X-Mailer:/",
                    position: (223, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (224, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A regexp pattern matching the header",
                    position: (224, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (220, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "action",
               position: (226, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (226, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (227, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (227, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (227, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (228, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "DUNNO",
                    position: (228, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (229, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "BCC mail@example.com",
                    position: (229, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (230, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The action to be executed when the pattern is matched",
                    position: (230, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (226, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (219, 15),
         },
        ),
       ],
       recursive: false,
       position: (218, 3),
      },
      position: (217, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "headerChecks",
        position: (235, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Addition,
      operands: [
       FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (235, 18),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\n",
            position: (235, 36),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (235, 41),
          },
          arguments: [
           Function {
            argument: Some(
             "x",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "x",
                 position: (235, 52),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "pattern",
                   position: (235, 54),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: " ",
               position: (235, 62),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "x",
                 position: (235, 65),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "action",
                   position: (235, 67),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
            position: (235, 46),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (235, 77),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "headerChecks",
               position: (235, 81),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (235, 97),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "extraHeaderChecks",
           position: (235, 101),
          },
         ],
        },
        default: None,
       },
      ],
      position: (235, 95),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "aliases",
        position: (237, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "seperator",
           position: (237, 17),
          },
         ],
        },
        IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (237, 32),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "aliasMapType",
               position: (237, 36),
              },
             ],
            },
            default: None,
           },
           String {
            parts: [
             Raw {
              content: "hash",
              position: (237, 53),
             },
            ],
           },
          ],
          position: (237, 49),
         },
         then: String {
          parts: [
           Raw {
            content: ":",
            position: (237, 65),
           },
          ],
         },
         else_: String {
          parts: [],
         },
         position: (237, 29),
        },
       ),
      ],
      target: BinaryOperation {
       operator: Addition,
       operands: [
        BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (238, 5),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (238, 21),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "postmasterAlias",
                  position: (238, 25),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [],
              },
             ],
             position: (238, 41),
            },
            String {
             parts: [
              Raw {
               content: "postmaster",
               position: (239, 1),
              },
              Expression {
               expression: Variable {
                identifier: "seperator",
                position: (239, 19),
               },
              },
              Raw {
               content: " ",
               position: (239, 29),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (239, 32),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "postmasterAlias",
                   position: (239, 36),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (239, 52),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (241, 7),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (241, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "rootAlias",
                  position: (241, 27),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [],
              },
             ],
             position: (241, 37),
            },
            String {
             parts: [
              Raw {
               content: "root",
               position: (242, 1),
              },
              Expression {
               expression: Variable {
                identifier: "seperator",
                position: (242, 13),
               },
              },
              Raw {
               content: " ",
               position: (242, 23),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (242, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "rootAlias",
                   position: (242, 30),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (242, 40),
              },
             ],
            },
           ],
          },
         ],
         position: (241, 5),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (244, 7),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "extraAliases",
            position: (244, 11),
           },
          ],
         },
         default: None,
        },
       ],
       position: (244, 5),
      },
      position: (237, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "aliasesFile",
        position: (247, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (247, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (247, 22),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-aliases",
          position: (247, 33),
         },
        ],
       },
       Variable {
        identifier: "aliases",
        position: (247, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "canonicalFile",
        position: (248, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (248, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (248, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-canonical",
          position: (248, 35),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (248, 54),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "canonical",
           position: (248, 58),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "virtualFile",
        position: (249, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (249, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (249, 22),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-virtual",
          position: (249, 33),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (249, 50),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "virtual",
           position: (249, 54),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "localRecipientMapFile",
        position: (250, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (250, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (250, 32),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-local-recipient-map",
          position: (250, 43),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "concatMapStrings",
         position: (250, 73),
        },
        arguments: [
         Function {
          argument: Some(
           "x",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: BinaryOperation {
           operator: Addition,
           operands: [
            Variable {
             identifier: "x",
             position: (250, 94),
            },
            String {
             parts: [
              Raw {
               content: " ACCEPT\n",
               position: (250, 99),
              },
             ],
            },
           ],
           position: (250, 96),
          },
          position: (250, 91),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (250, 111),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "localRecipients",
             position: (250, 115),
            },
           ],
          },
          default: None,
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "checkClientAccessFile",
        position: (251, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (251, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (251, 32),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-check-client-access",
          position: (251, 43),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (251, 72),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "dnsBlacklistOverrides",
           position: (251, 76),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mainCfFile",
        position: (252, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (252, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (252, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-main.cf",
          position: (252, 32),
         },
        ],
       },
       Variable {
        identifier: "mainCf",
        position: (252, 49),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "masterCfFile",
        position: (253, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (253, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (253, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-master.cf",
          position: (253, 34),
         },
        ],
       },
       Variable {
        identifier: "masterCfContent",
        position: (253, 53),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "transportFile",
        position: (254, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (254, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (254, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-transport",
          position: (254, 35),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (254, 54),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "transport",
           position: (254, 58),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "headerChecksFile",
        position: (255, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (255, 22),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (255, 27),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "postfix-header-checks",
          position: (255, 38),
         },
        ],
       },
       Variable {
        identifier: "headerChecks",
        position: (255, 61),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (263, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (265, 5),
           },
           Raw {
            content: "postfix",
            position: (265, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (267, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (267, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (268, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (268, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (268, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (269, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (269, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (270, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to run the Postfix mail server.",
                    position: (270, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (267, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableSmtp",
               position: (273, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (273, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (274, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (274, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (274, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (275, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (275, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (276, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable smtp in master.cf.",
                    position: (276, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (273, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableSubmission",
               position: (279, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (279, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (280, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (280, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (280, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (281, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (281, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (282, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable smtp submission.",
                    position: (282, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (279, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableSubmissions",
               position: (285, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (285, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (286, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (286, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (286, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (287, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (287, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (288, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable smtp submission via smtps.\n\nAccording to RFC 8314 this should be preferred\nover STARTTLS for submission of messages by end user clients.\n",
                    position: (289, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (285, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "submissionOptions",
               position: (296, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (296, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (297, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (297, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (297, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (297, 36),
                    },
                   ],
                  },
                  position: (297, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (298, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_tls_security_level",
                       position: (299, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "encrypt",
                       position: (299, 39),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_auth_enable",
                       position: (300, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "yes",
                       position: (300, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_client_restrictions",
                       position: (301, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "permit_sasl_authenticated,reject",
                       position: (301, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "milter_macro_daemon_name",
                       position: (302, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "ORIGINATING",
                       position: (302, 39),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (298, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (304, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_tls_security_level",
                       position: (305, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "encrypt",
                       position: (305, 39),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_auth_enable",
                       position: (306, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "yes",
                       position: (306, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_type",
                       position: (307, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "dovecot",
                       position: (307, 30),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_client_restrictions",
                       position: (308, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "permit_sasl_authenticated,reject",
                       position: (308, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "milter_macro_daemon_name",
                       position: (309, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "ORIGINATING",
                       position: (309, 39),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (304, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (311, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Options for the submission config in master.cf",
                    position: (311, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (296, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "submissionsOptions",
               position: (314, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (314, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (315, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (315, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (315, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (315, 36),
                    },
                   ],
                  },
                  position: (315, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (316, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_auth_enable",
                       position: (317, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "yes",
                       position: (317, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_client_restrictions",
                       position: (318, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "permit_sasl_authenticated,reject",
                       position: (318, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "milter_macro_daemon_name",
                       position: (319, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "ORIGINATING",
                       position: (319, 39),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (316, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (321, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_auth_enable",
                       position: (322, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "yes",
                       position: (322, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_sasl_type",
                       position: (323, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "dovecot",
                       position: (323, 30),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtpd_client_restrictions",
                       position: (324, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "permit_sasl_authenticated,reject",
                       position: (324, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "milter_macro_daemon_name",
                       position: (325, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "ORIGINATING",
                       position: (325, 39),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (321, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (327, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Options for the submission config via smtps in master.cf.\n\nsmtpd_tls_security_level will be set to encrypt, if it is missing\nor has one of the values \"may\" or \"none\".\n\nsmtpd_tls_wrappermode with value \"yes\" will be added automatically.\n",
                    position: (328, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (314, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "setSendmail",
               position: (337, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (337, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (338, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (338, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (338, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (339, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (339, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (340, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to set the system sendmail to postfix's.",
                    position: (340, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (337, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (343, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (343, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (344, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (344, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (344, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (345, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "postfix",
                    position: (345, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (346, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "What to call the Postfix user (must be used only for postfix).",
                    position: (346, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (343, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (349, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (349, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (350, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (350, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (350, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (351, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "postfix",
                    position: (351, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (352, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "What to call the Postfix group (must be used only for postfix).",
                    position: (352, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (349, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "setgidGroup",
               position: (355, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (355, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (356, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (356, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (356, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (357, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "postdrop",
                    position: (357, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (358, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          How to call postfix setgid group (for postdrop). Should\n          be uniquely used group.\n        ",
                    position: (358, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (355, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "networks",
               position: (364, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (364, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (365, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (365, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (365, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (365, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "listOf",
                        position: (365, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (365, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (365, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (366, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (366, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (367, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "192.168.0.1/24",
                      position: (367, 21),
                     },
                    ],
                   },
                  ],
                  position: (367, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (368, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Net masks for trusted - allowed to relay mail to third parties -\n          hosts. Leave empty to use mynetworks_style configuration or use\n          default (localhost-only).\n        ",
                    position: (368, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (364, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "networksStyle",
               position: (375, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (375, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (376, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (376, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (376, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (377, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (378, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Name of standard way of trusted network specification to use,\n          leave blank if you specify it explicitly or if you want to use\n          default (localhost-only).\n        ",
                    position: (378, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (375, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "hostname",
               position: (385, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (385, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (386, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (386, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (386, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (387, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (388, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Hostname to use. Leave blank to use just the hostname of machine.\n          It should be FQDN.\n        ",
                    position: (388, 23),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (385, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "domain",
               position: (394, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (394, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (395, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (395, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (395, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (396, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (397, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Domain to use. Leave blank to use hostname minus first component.\n        ",
                    position: (397, 23),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (394, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "origin",
               position: (402, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (402, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (403, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (403, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (403, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (404, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (405, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Origin to use in outgoing e-mail. Leave blank to use hostname.\n        ",
                    position: (405, 23),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (402, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "destination",
               position: (410, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (410, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (411, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (411, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (411, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (411, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "listOf",
                        position: (411, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (411, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (411, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (412, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (412, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (413, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "localhost",
                      position: (413, 21),
                     },
                    ],
                   },
                  ],
                  position: (413, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (414, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Full (!) list of domains we deliver locally. Leave blank for\n          acceptable Postfix default.\n        ",
                    position: (414, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (410, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "relayDomains",
               position: (420, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (420, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (421, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (421, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (421, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (421, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "listOf",
                        position: (421, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (421, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (421, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (422, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (422, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (423, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "localdomain",
                      position: (423, 21),
                     },
                    ],
                   },
                  ],
                  position: (423, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (424, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          List of domains we agree to relay to. Default is empty.\n        ",
                    position: (424, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (420, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "relayHost",
               position: (429, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (429, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (430, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (430, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (430, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (431, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (432, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Mail relay for outbound mail.\n        ",
                    position: (432, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (429, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "relayPort",
               position: (437, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (437, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (438, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (438, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (438, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (439, 9),
                   },
                  ],
                 },
                 Int {
                  value: 25,
                  position: (439, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (440, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          SMTP port for relay mail relay.\n        ",
                    position: (440, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (437, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "lookupMX",
               position: (445, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (445, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (446, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (446, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (446, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (447, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (447, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (448, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Whether relay specified is just domain whose MX must be used.\n        ",
                    position: (448, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (445, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "postmasterAlias",
               position: (453, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (453, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (454, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (454, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (454, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (455, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "root",
                    position: (455, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (456, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Who should receive postmaster e-mail. Multiple values can be added by\n          separating values with comma.\n        ",
                    position: (456, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (453, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rootAlias",
               position: (462, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (462, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (463, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (463, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (463, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (464, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (465, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Who should receive root e-mail. Blank for no redirection.\n          Multiple values can be added by separating values with comma.\n        ",
                    position: (465, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (462, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraAliases",
               position: (471, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (471, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (472, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (472, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (472, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (473, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (474, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Additional entries to put verbatim into aliases file, cf. man-page aliases(8).\n        ",
                    position: (474, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (471, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "aliasMapType",
               position: (479, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (479, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (480, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (480, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (480, 28),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "hash",
                         position: (480, 36),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "regexp",
                         position: (480, 43),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "pcre",
                         position: (480, 52),
                        },
                       ],
                      },
                     ],
                     position: (480, 33),
                    },
                   ],
                  },
                  position: (480, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (481, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "hash",
                    position: (481, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (482, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "regexp",
                    position: (482, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (483, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The format the alias map should have. Use regexp if you want to use regular expressions.",
                    position: (483, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (479, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (486, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (486, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (487, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (487, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (487, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "oneOf",
                      position: (487, 37),
                     },
                     arguments: [
                      List {
                       elements: [
                        Variable {
                         identifier: "bool",
                         position: (487, 45),
                        },
                        Variable {
                         identifier: "str",
                         position: (487, 50),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "listOf",
                          position: (487, 55),
                         },
                         arguments: [
                          Variable {
                           identifier: "str",
                           position: (487, 62),
                          },
                         ],
                        },
                       ],
                       position: (487, 43),
                      },
                     ],
                    },
                   ],
                  },
                  position: (487, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (488, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The main.cf configuration file as key value set.\n",
                    position: (489, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (491, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "mail_owner",
                       position: (492, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "postfix",
                       position: (492, 25),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "smtp_tls_security_level",
                       position: (493, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "may",
                       position: (493, 38),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (491, 19),
                 },
                ),
               ],
               recursive: false,
               position: (486, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (497, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (497, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (498, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (498, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (498, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (499, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (500, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Extra lines to be added verbatim to the main.cf configuration file.\n        ",
                    position: (500, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (497, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tlsTrustedAuthorities",
               position: (505, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (505, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (506, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (506, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (506, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (507, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (507, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "cacert",
                        position: (507, 27),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/etc/ssl/certs/ca-bundle.crt",
                    position: (507, 34),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (508, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (508, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (508, 43),
                     },
                     Raw {
                      content: "$",
                      position: (508, 44),
                     },
                     Raw {
                      content: "{pkgs.cacert}/etc/ssl/certs/ca-bundle.crt\"",
                      position: (508, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (509, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "File containing trusted certification authorities (CA) to verify certificates of mailservers contacted for mail delivery. This basically sets smtp_tls_CAfile and enables opportunistic tls. Defaults to NixOS trusted certification authorities.\n",
                    position: (510, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (505, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sslCert",
               position: (514, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (514, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (515, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (515, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (515, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (516, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (517, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "SSL certificate to use.",
                    position: (517, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (514, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sslKey",
               position: (520, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (520, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (521, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (521, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (521, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (522, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (523, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "SSL key to use.",
                    position: (523, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (520, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "recipientDelimiter",
               position: (526, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (526, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (527, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (527, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (527, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (528, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (529, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "+",
                    position: (529, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (530, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Delimiter for address extension: so mail to user+test can be handled by ~user/.forward+test\n        ",
                    position: (530, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (526, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "canonical",
               position: (535, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (535, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (536, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (536, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (536, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (537, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (538, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Entries for the <citerefentry><refentrytitle>canonical</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> table.\n",
                    position: (539, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (535, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "virtual",
               position: (544, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (544, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (545, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (545, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (545, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (546, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (547, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Entries for the virtual alias map, cf. man-page virtual(5).\n        ",
                    position: (547, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (544, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "virtualMapType",
               position: (552, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (552, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (553, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (553, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (553, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "hash",
                        position: (553, 29),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "regexp",
                        position: (553, 36),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "pcre",
                        position: (553, 45),
                       },
                      ],
                     },
                    ],
                    position: (553, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (554, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "hash",
                    position: (554, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (555, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "What type of virtual alias map file to use. Use <literal>\"regexp\"</literal> for regular expressions.\n",
                    position: (556, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (552, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "localRecipients",
               position: (560, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (560, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (561, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (561, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (561, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (561, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (561, 43),
                      },
                     ],
                    },
                   ],
                  },
                  position: (561, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (562, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (562, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (563, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of accepted local users. Specify a bare username, an\n<literal>\"@domain.tld\"</literal> wild-card, or a complete\n<literal>\"user@domain.tld\"</literal> address. If set, these names end\nup in the local recipient map -- see the local(8) man-page -- and\neffectively replace the system user database lookup that's otherwise\nused by default.\n",
                    position: (564, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (560, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "transport",
               position: (573, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (573, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (574, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (575, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (575, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (575, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (576, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n          Entries for the transport map, cf. man-page transport(8).\n        ",
                    position: (576, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (573, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dnsBlacklists",
               position: (581, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (581, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (582, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (582, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (583, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (583, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (583, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (583, 35),
                    },
                   ],
                  },
                  position: (583, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (584, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "dns blacklist servers to use with smtpd_client_restrictions",
                    position: (584, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (581, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dnsBlacklistOverrides",
               position: (587, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (587, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (588, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (589, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (589, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (589, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (590, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "contents of check_client_access for overriding dnsBlacklists",
                    position: (590, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (587, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "masterConfig",
               position: (593, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (593, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (594, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (594, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (594, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (594, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (594, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "masterCfOptions",
                      position: (594, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (595, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (595, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (596, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "submission",
                       position: (597, 13),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "type",
                          position: (598, 15),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "inet",
                          position: (598, 23),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "args",
                          position: (599, 15),
                         },
                        ],
                       },
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "-o",
                            position: (599, 25),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "smtpd_tls_security_level=encrypt",
                            position: (599, 30),
                           },
                          ],
                         },
                        ],
                        position: (599, 22),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (597, 26),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (597, 11),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (602, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "An attribute set of service options, which correspond to the service\ndefinitions usually done within the Postfix\n<filename>master.cf</filename> file.\n",
                    position: (603, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (593, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraMasterConf",
               position: (609, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (609, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (610, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (610, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (610, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (611, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (612, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "submission inet n - n - - smtpd",
                    position: (612, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (613, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra lines to append to the generated master.cf file.",
                    position: (613, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (609, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableHeaderChecks",
               position: (616, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (616, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (617, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (617, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (617, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (618, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (618, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (619, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (619, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (620, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable postfix header checks",
                    position: (620, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (616, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "headerChecks",
               position: (623, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (623, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (624, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (624, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (624, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (624, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (624, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "headerCheckOptions",
                      position: (624, 46),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (625, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (625, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (626, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "pattern",
                         position: (626, 23),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/^X-Spam-Flag:/",
                         position: (626, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "action",
                         position: (626, 52),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "REDIRECT spam@example.com",
                         position: (626, 62),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (626, 21),
                   },
                  ],
                  position: (626, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (627, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Postfix header checks.",
                    position: (627, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (623, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraHeaderChecks",
               position: (630, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (630, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (631, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (631, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (631, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (632, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (633, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/^X-Spam-Flag:/ REDIRECT spam@example.com",
                    position: (633, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (634, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra lines to /etc/postfix/header_checks file.",
                    position: (634, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (630, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "aliasFiles",
               position: (637, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (637, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (638, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (638, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (638, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (638, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (638, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (639, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (639, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (640, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Aliases' tables to be compiled and placed into /var/lib/postfix/conf.",
                    position: (640, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (637, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mapFiles",
               position: (643, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (643, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (644, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (644, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (644, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (644, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (644, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (645, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (645, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (646, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maps to be compiled and placed into /var/lib/postfix/conf.",
                    position: (646, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (643, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "useSrs",
               position: (649, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (649, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (650, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (650, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (650, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (651, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (651, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (652, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable sender rewriting scheme",
                    position: (652, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (649, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (265, 24),
         },
        ),
       ],
       recursive: false,
       position: (263, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (662, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (662, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (662, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (662, 24),
           },
           Raw {
            content: "postfix",
            position: (662, 33),
           },
           Raw {
            content: "enable",
            position: (662, 41),
           },
          ],
         },
         default: None,
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkMerge",
          position: (662, 49),
         },
         arguments: [
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (665, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "etc",
                     position: (666, 9),
                    },
                    Raw {
                     content: "postfix",
                     position: (666, 13),
                    },
                    Raw {
                     content: "source",
                     position: (666, 21),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/var/lib/postfix/conf",
                     position: (666, 31),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "systemPackages",
                     position: (669, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (669, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "postfix",
                        position: (669, 33),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (669, 26),
                  },
                 ),
                ],
                recursive: false,
                position: (665, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (672, 7),
                 },
                 Raw {
                  content: "pfix-srsd",
                  position: (672, 16),
                 },
                 Raw {
                  content: "enable",
                  position: (672, 26),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (672, 35),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "services",
                   position: (672, 42),
                  },
                  Raw {
                   content: "postfix",
                   position: (672, 51),
                  },
                  Raw {
                   content: "useSrs",
                   position: (672, 59),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (674, 7),
                 },
                 Raw {
                  content: "mail",
                  position: (674, 16),
                 },
                 Raw {
                  content: "sendmailSetuidWrapper",
                  position: (674, 21),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkIf",
                 position: (674, 45),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (674, 50),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "services",
                     position: (674, 57),
                    },
                    Raw {
                     content: "postfix",
                     position: (674, 66),
                    },
                    Raw {
                     content: "setSendmail",
                     position: (674, 74),
                    },
                   ],
                  },
                  default: None,
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "program",
                       position: (675, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "sendmail",
                       position: (675, 20),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "source",
                       position: (676, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (676, 21),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "postfix",
                           position: (676, 26),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/bin/sendmail",
                       position: (676, 34),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "owner",
                       position: (677, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "root",
                       position: (677, 18),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (678, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "setgidGroup",
                     position: (678, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "setuid",
                       position: (679, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (679, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "setgid",
                       position: (680, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (680, 18),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (674, 86),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "security",
                  position: (683, 7),
                 },
                 Raw {
                  content: "wrappers",
                  position: (683, 16),
                 },
                 Raw {
                  content: "mailq",
                  position: (683, 25),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "program",
                     position: (684, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mailq",
                     position: (684, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "source",
                     position: (685, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (685, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (685, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/mailq",
                     position: (685, 34),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "owner",
                     position: (686, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "root",
                     position: (686, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (687, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "setgidGroup",
                   position: (687, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setuid",
                     position: (688, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (688, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setgid",
                     position: (689, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (689, 18),
                  },
                 ),
                ],
                recursive: false,
                position: (683, 33),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "security",
                  position: (692, 7),
                 },
                 Raw {
                  content: "wrappers",
                  position: (692, 16),
                 },
                 Raw {
                  content: "postqueue",
                  position: (692, 25),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "program",
                     position: (693, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postqueue",
                     position: (693, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "source",
                     position: (694, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (694, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (694, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/postqueue",
                     position: (694, 34),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "owner",
                     position: (695, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "root",
                     position: (695, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (696, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "setgidGroup",
                   position: (696, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setuid",
                     position: (697, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (697, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setgid",
                     position: (698, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (698, 18),
                  },
                 ),
                ],
                recursive: false,
                position: (692, 37),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "security",
                  position: (701, 7),
                 },
                 Raw {
                  content: "wrappers",
                  position: (701, 16),
                 },
                 Raw {
                  content: "postdrop",
                  position: (701, 25),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "program",
                     position: (702, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postdrop",
                     position: (702, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "source",
                     position: (703, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (703, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (703, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/postdrop",
                     position: (703, 34),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "owner",
                     position: (704, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "root",
                     position: (704, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (705, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "setgidGroup",
                   position: (705, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setuid",
                     position: (706, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (706, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "setgid",
                     position: (707, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (707, 18),
                  },
                 ),
                ],
                recursive: false,
                position: (701, 36),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (710, 7),
                 },
                 Raw {
                  content: "users",
                  position: (710, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (710, 21),
                },
                arguments: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "user",
                    position: (710, 36),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "postfix",
                      position: (710, 45),
                     },
                    ],
                   },
                  ],
                  position: (710, 41),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "postfix",
                       position: (711, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "description",
                          position: (712, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Postfix mail server user",
                          position: (712, 28),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "uid",
                          position: (713, 13),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (713, 19),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "ids",
                           position: (713, 26),
                          },
                          Raw {
                           content: "uids",
                           position: (713, 30),
                          },
                          Raw {
                           content: "postfix",
                           position: (713, 35),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "group",
                          position: (714, 13),
                         },
                        ],
                       },
                       Variable {
                        identifier: "group",
                        position: (714, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (711, 21),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (711, 9),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (718, 7),
                 },
                 Raw {
                  content: "groups",
                  position: (718, 13),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (719, 9),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "group",
                      position: (719, 24),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "postfix",
                        position: (719, 34),
                       },
                      ],
                     },
                    ],
                    position: (719, 30),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Expression {
                         expression: Variable {
                          identifier: "group",
                          position: (720, 13),
                         },
                        },
                        Raw {
                         content: "gid",
                         position: (720, 20),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (720, 26),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "ids",
                          position: (720, 33),
                         },
                         Raw {
                          content: "gids",
                          position: (720, 37),
                         },
                         Raw {
                          content: "postfix",
                          position: (720, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    recursive: false,
                    position: (720, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (722, 12),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "setgidGroup",
                      position: (722, 27),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "postdrop",
                        position: (722, 43),
                       },
                      ],
                     },
                    ],
                    position: (722, 39),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Expression {
                         expression: Variable {
                          identifier: "setgidGroup",
                          position: (723, 13),
                         },
                        },
                        Raw {
                         content: "gid",
                         position: (723, 26),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (723, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "ids",
                          position: (723, 39),
                         },
                         Raw {
                          content: "gids",
                          position: (723, 43),
                         },
                         Raw {
                          content: "postdrop",
                          position: (723, 48),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    recursive: false,
                    position: (723, 9),
                   },
                  ],
                 },
                ],
                position: (722, 9),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (726, 7),
                 },
                 Raw {
                  content: "services",
                  position: (726, 15),
                 },
                 Raw {
                  content: "postfix",
                  position: (726, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (727, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Postfix mail server",
                     position: (727, 26),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (729, 11),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (729, 25),
                      },
                     ],
                    },
                   ],
                   position: (729, 22),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (730, 11),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (730, 22),
                      },
                     ],
                    },
                   ],
                   position: (730, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (731, 11),
                    },
                   ],
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (731, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "postfix",
                        position: (731, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (731, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (733, 11),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Type",
                        position: (734, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "forking",
                        position: (734, 21),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Restart",
                        position: (735, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "always",
                        position: (735, 24),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PIDFile",
                        position: (736, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/var/lib/postfix/queue/pid/master.pid",
                        position: (736, 24),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (737, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (737, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "postfix",
                            position: (737, 33),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/postfix start",
                        position: (737, 41),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStop",
                        position: (738, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (738, 27),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "postfix",
                            position: (738, 32),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/postfix stop",
                        position: (738, 40),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecReload",
                        position: (739, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (739, 29),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "postfix",
                            position: (739, 34),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/postfix reload",
                        position: (739, 42),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (733, 27),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (742, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "# Backwards compatibility\nif [ ! -d /var/lib/postfix ] && [ -d /var/postfix ]; then\n  mkdir -p /var/lib\n  mv /var/postfix /var/lib/postfix\nfi\n\n# All permissions set according ",
                     position: (743, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (749, 47),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (749, 52),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/etc/postfix/postfix-files script\nmkdir -p /var/lib/postfix /var/lib/postfix/queue/{pid,public,maildrop}\nchmod 0755 /var/lib/postfix\nchown root:root /var/lib/postfix\n\nrm -rf /var/lib/postfix/conf\nmkdir -p /var/lib/postfix/conf\nchmod 0755 /var/lib/postfix/conf\nln -sf ",
                     position: (749, 60),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (757, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (757, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/etc/postfix/postfix-files /var/lib/postfix/conf/postfix-files\nln -sf ",
                     position: (757, 35),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "mainCfFile",
                      position: (758, 22),
                     },
                    },
                    Raw {
                     content: " /var/lib/postfix/conf/main.cf\nln -sf ",
                     position: (758, 33),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "masterCfFile",
                      position: (759, 22),
                     },
                    },
                    Raw {
                     content: " /var/lib/postfix/conf/master.cf\n\n",
                     position: (759, 35),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "concatStringsSep",
                       position: (761, 15),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "\n",
                          position: (761, 33),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mapAttrsToList",
                         position: (761, 38),
                        },
                        arguments: [
                         Function {
                          argument: Some(
                           "to",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: Function {
                           argument: Some(
                            "from",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: String {
                            parts: [
                             Raw {
                              content: "ln -sf ",
                              position: (762, 1),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "from",
                               position: (762, 24),
                              },
                             },
                             Raw {
                              content: " /var/lib/postfix/conf/",
                              position: (762, 29),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "to",
                               position: (762, 54),
                              },
                             },
                             Raw {
                              content: "\n",
                              position: (762, 57),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "pkgs",
                                position: (763, 17),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "postfix",
                                  position: (763, 22),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: "/bin/postalias /var/lib/postfix/conf/",
                              position: (763, 30),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "to",
                               position: (763, 69),
                              },
                             },
                             Raw {
                              content: "\n",
                              position: (763, 72),
                             },
                            ],
                           },
                           position: (761, 58),
                          },
                          position: (761, 54),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (764, 17),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "aliasFiles",
                             position: (764, 21),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (764, 33),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "concatStringsSep",
                       position: (765, 15),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "\n",
                          position: (765, 33),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mapAttrsToList",
                         position: (765, 38),
                        },
                        arguments: [
                         Function {
                          argument: Some(
                           "to",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: Function {
                           argument: Some(
                            "from",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: String {
                            parts: [
                             Raw {
                              content: "ln -sf ",
                              position: (766, 1),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "from",
                               position: (766, 24),
                              },
                             },
                             Raw {
                              content: " /var/lib/postfix/conf/",
                              position: (766, 29),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "to",
                               position: (766, 54),
                              },
                             },
                             Raw {
                              content: "\n",
                              position: (766, 57),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "pkgs",
                                position: (767, 17),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "postfix",
                                  position: (767, 22),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: "/bin/postmap /var/lib/postfix/conf/",
                              position: (767, 30),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "to",
                               position: (767, 67),
                              },
                             },
                             Raw {
                              content: "\n",
                              position: (767, 70),
                             },
                            ],
                           },
                           position: (765, 58),
                          },
                          position: (765, 54),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (768, 17),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mapFiles",
                             position: (768, 21),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\n\nmkdir -p /var/spool/mail\nchown root:root /var/spool/mail\nchmod a+rwxt /var/spool/mail\nln -sf /var/spool/mail /var/\n\n#Finally delegate to postfix checking remain directories in /var/lib/postfix and set permissions on them\n",
                     position: (768, 31),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (776, 15),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postfix",
                         position: (776, 20),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/postfix set-permissions config_directory=/var/lib/postfix/conf\n",
                     position: (776, 28),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (727, 9),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (780, 7),
                 },
                 Raw {
                  content: "postfix",
                  position: (780, 16),
                 },
                 Raw {
                  content: "config",
                  position: (780, 24),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "mapAttrs",
                   position: (780, 34),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "_",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: Function {
                     argument: Some(
                      "v",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "mkDefault",
                       position: (780, 50),
                      },
                      arguments: [
                       Variable {
                        identifier: "v",
                        position: (780, 60),
                       },
                      ],
                     },
                     position: (780, 47),
                    },
                    position: (780, 44),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "compatibility_level",
                         position: (781, 9),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (781, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "postfix",
                          position: (781, 37),
                         },
                         Raw {
                          content: "version",
                          position: (781, 45),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "mail_owner",
                         position: (782, 9),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (782, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "user",
                          position: (782, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default_privs",
                         position: (783, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "nobody",
                         position: (783, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "data_directory",
                         position: (786, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/var/lib/postfix/data",
                         position: (786, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "queue_directory",
                         position: (787, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/var/lib/postfix/queue",
                         position: (787, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "meta_directory",
                         position: (790, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (790, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (790, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/etc/postfix",
                         position: (790, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "command_directory",
                         position: (791, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (791, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (791, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin",
                         position: (791, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sample_directory",
                         position: (792, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/etc/postfix",
                         position: (792, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "newaliases_path",
                         position: (793, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (793, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (793, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/newaliases",
                         position: (793, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "mailq_path",
                         position: (794, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (794, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (794, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/mailq",
                         position: (794, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "readme_directory",
                         position: (795, 9),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (795, 32),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sendmail_path",
                         position: (796, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (796, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (796, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/sendmail",
                         position: (796, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "daemon_directory",
                         position: (797, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (797, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (797, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/libexec/postfix",
                         position: (797, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "manpage_directory",
                         position: (798, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (798, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (798, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/share/man",
                         position: (798, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "html_directory",
                         position: (799, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (799, 35),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "postfix",
                             position: (799, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/share/postfix/doc/html",
                         position: (799, 48),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "shlib_directory",
                         position: (800, 9),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (800, 32),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "mail_spool_directory",
                         position: (801, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/var/spool/mail/",
                         position: (801, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "setgid_group",
                         position: (802, 9),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (802, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "setgidGroup",
                          position: (802, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    recursive: false,
                    position: (780, 63),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "optionalAttrs",
                     position: (804, 10),
                    },
                    arguments: [
                     BinaryOperation {
                      operator: NotEqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (804, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "relayHost",
                           position: (804, 29),
                          },
                         ],
                        },
                        default: None,
                       },
                       String {
                        parts: [],
                       },
                      ],
                      position: (804, 39),
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "relayhost",
                           position: (804, 48),
                          },
                         ],
                        },
                        IfThenElse {
                         predicate: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (804, 63),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "lookupMX",
                             position: (804, 67),
                            },
                           ],
                          },
                          default: None,
                         },
                         then: String {
                          parts: [
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (805, 68),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "relayHost",
                                position: (805, 72),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: ":",
                            position: (805, 82),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "toString",
                              position: (805, 85),
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (805, 94),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "relayPort",
                                  position: (805, 98),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                          ],
                         },
                         else_: String {
                          parts: [
                           Raw {
                            content: "[",
                            position: (806, 66),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (806, 69),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "relayHost",
                                position: (806, 73),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "]:",
                            position: (806, 83),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "toString",
                              position: (806, 87),
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (806, 96),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "relayPort",
                                  position: (806, 100),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                          ],
                         },
                         position: (804, 60),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (804, 46),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionalAttrs",
                       position: (807, 10),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (807, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "networking",
                           position: (807, 31),
                          },
                          Raw {
                           content: "enableIPv6",
                           position: (807, 42),
                          },
                         ],
                        },
                        default: None,
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "inet_protocols",
                             position: (807, 55),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkDefault",
                            position: (807, 72),
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "all",
                               position: (807, 83),
                              },
                             ],
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (807, 53),
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: Update,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionalAttrs",
                         position: (808, 10),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: NotEqualTo,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (808, 25),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "networks",
                               position: (808, 29),
                              },
                             ],
                            },
                            default: None,
                           },
                           Variable {
                            identifier: "null",
                            position: (808, 41),
                           },
                          ],
                          position: (808, 38),
                         },
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "mynetworks",
                               position: (808, 49),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (808, 62),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "networks",
                                position: (808, 66),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                          ],
                          recursive: false,
                          position: (808, 47),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Update,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "optionalAttrs",
                           position: (809, 10),
                          },
                          arguments: [
                           BinaryOperation {
                            operator: NotEqualTo,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (809, 25),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "networksStyle",
                                 position: (809, 29),
                                },
                               ],
                              },
                              default: None,
                             },
                             String {
                              parts: [],
                             },
                            ],
                            position: (809, 43),
                           },
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "mynetworks_style",
                                 position: (809, 52),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (809, 71),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "networksStyle",
                                  position: (809, 75),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                            ],
                            recursive: false,
                            position: (809, 50),
                           },
                          ],
                         },
                         BinaryOperation {
                          operator: Update,
                          operands: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "optionalAttrs",
                             position: (810, 10),
                            },
                            arguments: [
                             BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (810, 25),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "hostname",
                                   position: (810, 29),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               String {
                                parts: [],
                               },
                              ],
                              position: (810, 38),
                             },
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "myhostname",
                                   position: (810, 47),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (810, 60),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "hostname",
                                    position: (810, 64),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                              ],
                              recursive: false,
                              position: (810, 45),
                             },
                            ],
                           },
                           BinaryOperation {
                            operator: Update,
                            operands: [
                             FunctionApplication {
                              function: Variable {
                               identifier: "optionalAttrs",
                               position: (811, 10),
                              },
                              arguments: [
                               BinaryOperation {
                                operator: NotEqualTo,
                                operands: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (811, 25),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "domain",
                                     position: (811, 29),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 String {
                                  parts: [],
                                 },
                                ],
                                position: (811, 36),
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "mydomain",
                                     position: (811, 45),
                                    },
                                   ],
                                  },
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (811, 56),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "domain",
                                      position: (811, 60),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (811, 43),
                               },
                              ],
                             },
                             BinaryOperation {
                              operator: Update,
                              operands: [
                               FunctionApplication {
                                function: Variable {
                                 identifier: "optionalAttrs",
                                 position: (812, 10),
                                },
                                arguments: [
                                 BinaryOperation {
                                  operator: NotEqualTo,
                                  operands: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (812, 25),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "origin",
                                       position: (812, 29),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   String {
                                    parts: [],
                                   },
                                  ],
                                  position: (812, 36),
                                 },
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "myorigin",
                                       position: (812, 45),
                                      },
                                     ],
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (812, 57),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "origin",
                                        position: (812, 61),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (812, 43),
                                 },
                                ],
                               },
                               BinaryOperation {
                                operator: Update,
                                operands: [
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "optionalAttrs",
                                   position: (813, 10),
                                  },
                                  arguments: [
                                   BinaryOperation {
                                    operator: NotEqualTo,
                                    operands: [
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (813, 25),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "destination",
                                         position: (813, 29),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                     Variable {
                                      identifier: "null",
                                      position: (813, 44),
                                     },
                                    ],
                                    position: (813, 41),
                                   },
                                   Map {
                                    bindings: [
                                     KeyValue(
                                      AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "mydestination",
                                         position: (813, 52),
                                        },
                                       ],
                                      },
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (813, 68),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "destination",
                                          position: (813, 72),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     ),
                                    ],
                                    recursive: false,
                                    position: (813, 50),
                                   },
                                  ],
                                 },
                                 BinaryOperation {
                                  operator: Update,
                                  operands: [
                                   FunctionApplication {
                                    function: Variable {
                                     identifier: "optionalAttrs",
                                     position: (814, 10),
                                    },
                                    arguments: [
                                     BinaryOperation {
                                      operator: NotEqualTo,
                                      operands: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "cfg",
                                         position: (814, 25),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "relayDomains",
                                           position: (814, 29),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                       Variable {
                                        identifier: "null",
                                        position: (814, 45),
                                       },
                                      ],
                                      position: (814, 42),
                                     },
                                     Map {
                                      bindings: [
                                       KeyValue(
                                        AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "relay_domains",
                                           position: (814, 53),
                                          },
                                         ],
                                        },
                                        PropertyAccess {
                                         expression: Variable {
                                          identifier: "cfg",
                                          position: (814, 69),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "relayDomains",
                                            position: (814, 73),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                       ),
                                      ],
                                      recursive: false,
                                      position: (814, 51),
                                     },
                                    ],
                                   },
                                   BinaryOperation {
                                    operator: Update,
                                    operands: [
                                     FunctionApplication {
                                      function: Variable {
                                       identifier: "optionalAttrs",
                                       position: (815, 10),
                                      },
                                      arguments: [
                                       BinaryOperation {
                                        operator: NotEqualTo,
                                        operands: [
                                         PropertyAccess {
                                          expression: Variable {
                                           identifier: "cfg",
                                           position: (815, 25),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "recipientDelimiter",
                                             position: (815, 29),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                         String {
                                          parts: [],
                                         },
                                        ],
                                        position: (815, 48),
                                       },
                                       Map {
                                        bindings: [
                                         KeyValue(
                                          AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "recipient_delimiter",
                                             position: (815, 57),
                                            },
                                           ],
                                          },
                                          PropertyAccess {
                                           expression: Variable {
                                            identifier: "cfg",
                                            position: (815, 79),
                                           },
                                           attribute_path: AttributePath {
                                            attributes: [
                                             Raw {
                                              content: "recipientDelimiter",
                                              position: (815, 83),
                                             },
                                            ],
                                           },
                                           default: None,
                                          },
                                         ),
                                        ],
                                        recursive: false,
                                        position: (815, 55),
                                       },
                                      ],
                                     },
                                     BinaryOperation {
                                      operator: Update,
                                      operands: [
                                       FunctionApplication {
                                        function: Variable {
                                         identifier: "optionalAttrs",
                                         position: (816, 10),
                                        },
                                        arguments: [
                                         Variable {
                                          identifier: "haveAliases",
                                          position: (816, 24),
                                         },
                                         Map {
                                          bindings: [
                                           KeyValue(
                                            AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "alias_maps",
                                               position: (816, 38),
                                              },
                                             ],
                                            },
                                            List {
                                             elements: [
                                              String {
                                               parts: [
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "cfg",
                                                   position: (816, 56),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "aliasMapType",
                                                     position: (816, 60),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: ":/etc/postfix/aliases",
                                                 position: (816, 73),
                                                },
                                               ],
                                              },
                                             ],
                                             position: (816, 51),
                                            },
                                           ),
                                          ],
                                          recursive: false,
                                          position: (816, 36),
                                         },
                                        ],
                                       },
                                       BinaryOperation {
                                        operator: Update,
                                        operands: [
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "optionalAttrs",
                                           position: (817, 10),
                                          },
                                          arguments: [
                                           Variable {
                                            identifier: "haveTransport",
                                            position: (817, 24),
                                           },
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "transport_maps",
                                                 position: (817, 40),
                                                },
                                               ],
                                              },
                                              List {
                                               elements: [
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "hash:/etc/postfix/transport",
                                                   position: (817, 60),
                                                  },
                                                 ],
                                                },
                                               ],
                                               position: (817, 57),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (817, 38),
                                           },
                                          ],
                                         },
                                         BinaryOperation {
                                          operator: Update,
                                          operands: [
                                           FunctionApplication {
                                            function: Variable {
                                             identifier: "optionalAttrs",
                                             position: (818, 10),
                                            },
                                            arguments: [
                                             Variable {
                                              identifier: "haveVirtual",
                                              position: (818, 24),
                                             },
                                             Map {
                                              bindings: [
                                               KeyValue(
                                                AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "virtual_alias_maps",
                                                   position: (818, 38),
                                                  },
                                                 ],
                                                },
                                                List {
                                                 elements: [
                                                  String {
                                                   parts: [
                                                    Expression {
                                                     expression: PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "cfg",
                                                       position: (818, 64),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "virtualMapType",
                                                         position: (818, 68),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    },
                                                    Raw {
                                                     content: ":/etc/postfix/virtual",
                                                     position: (818, 83),
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                 position: (818, 59),
                                                },
                                               ),
                                              ],
                                              recursive: false,
                                              position: (818, 36),
                                             },
                                            ],
                                           },
                                           BinaryOperation {
                                            operator: Update,
                                            operands: [
                                             FunctionApplication {
                                              function: Variable {
                                               identifier: "optionalAttrs",
                                               position: (819, 10),
                                              },
                                              arguments: [
                                               Variable {
                                                identifier: "haveLocalRecipients",
                                                position: (819, 24),
                                               },
                                               Map {
                                                bindings: [
                                                 KeyValue(
                                                  AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "local_recipient_maps",
                                                     position: (819, 46),
                                                    },
                                                   ],
                                                  },
                                                  BinaryOperation {
                                                   operator: Concatenation,
                                                   operands: [
                                                    List {
                                                     elements: [
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "hash:/etc/postfix/local_recipients",
                                                         position: (819, 72),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                     position: (819, 69),
                                                    },
                                                    FunctionApplication {
                                                     function: Variable {
                                                      identifier: "optional",
                                                      position: (819, 113),
                                                     },
                                                     arguments: [
                                                      Variable {
                                                       identifier: "haveAliases",
                                                       position: (819, 122),
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "$alias_maps",
                                                         position: (819, 135),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                   position: (819, 110),
                                                  },
                                                 ),
                                                ],
                                                recursive: false,
                                                position: (819, 44),
                                               },
                                              ],
                                             },
                                             BinaryOperation {
                                              operator: Update,
                                              operands: [
                                               FunctionApplication {
                                                function: Variable {
                                                 identifier: "optionalAttrs",
                                                 position: (820, 10),
                                                },
                                                arguments: [
                                                 BinaryOperation {
                                                  operator: NotEqualTo,
                                                  operands: [
                                                   PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "cfg",
                                                     position: (820, 25),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "dnsBlacklists",
                                                       position: (820, 29),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                   List {
                                                    elements: [],
                                                    position: (820, 46),
                                                   },
                                                  ],
                                                  position: (820, 43),
                                                 },
                                                 Map {
                                                  bindings: [
                                                   KeyValue(
                                                    AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "smtpd_client_restrictions",
                                                       position: (820, 52),
                                                      },
                                                     ],
                                                    },
                                                    Variable {
                                                     identifier: "clientRestrictions",
                                                     position: (820, 80),
                                                    },
                                                   ),
                                                  ],
                                                  recursive: false,
                                                  position: (820, 50),
                                                 },
                                                ],
                                               },
                                               BinaryOperation {
                                                operator: Update,
                                                operands: [
                                                 FunctionApplication {
                                                  function: Variable {
                                                   identifier: "optionalAttrs",
                                                   position: (821, 10),
                                                  },
                                                  arguments: [
                                                   PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "cfg",
                                                     position: (821, 24),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "useSrs",
                                                       position: (821, 28),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                   Map {
                                                    bindings: [
                                                     KeyValue(
                                                      AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "sender_canonical_maps",
                                                         position: (822, 9),
                                                        },
                                                       ],
                                                      },
                                                      List {
                                                       elements: [
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "tcp:127.0.0.1:10001",
                                                           position: (822, 36),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (822, 33),
                                                      },
                                                     ),
                                                     KeyValue(
                                                      AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "sender_canonical_classes",
                                                         position: (823, 9),
                                                        },
                                                       ],
                                                      },
                                                      List {
                                                       elements: [
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "envelope_sender",
                                                           position: (823, 39),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (823, 36),
                                                      },
                                                     ),
                                                     KeyValue(
                                                      AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "recipient_canonical_maps",
                                                         position: (824, 9),
                                                        },
                                                       ],
                                                      },
                                                      List {
                                                       elements: [
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "tcp:127.0.0.1:10002",
                                                           position: (824, 39),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (824, 36),
                                                      },
                                                     ),
                                                     KeyValue(
                                                      AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "recipient_canonical_classes",
                                                         position: (825, 9),
                                                        },
                                                       ],
                                                      },
                                                      List {
                                                       elements: [
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "envelope_recipient",
                                                           position: (825, 42),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (825, 39),
                                                      },
                                                     ),
                                                    ],
                                                    recursive: false,
                                                    position: (821, 35),
                                                   },
                                                  ],
                                                 },
                                                 BinaryOperation {
                                                  operator: Update,
                                                  operands: [
                                                   FunctionApplication {
                                                    function: Variable {
                                                     identifier: "optionalAttrs",
                                                     position: (827, 10),
                                                    },
                                                    arguments: [
                                                     PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "cfg",
                                                       position: (827, 24),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "enableHeaderChecks",
                                                         position: (827, 28),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                     Map {
                                                      bindings: [
                                                       KeyValue(
                                                        AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "header_checks",
                                                           position: (827, 49),
                                                          },
                                                         ],
                                                        },
                                                        List {
                                                         elements: [
                                                          String {
                                                           parts: [
                                                            Raw {
                                                             content: "regexp:/etc/postfix/header_checks",
                                                             position: (827, 68),
                                                            },
                                                           ],
                                                          },
                                                         ],
                                                         position: (827, 65),
                                                        },
                                                       ),
                                                      ],
                                                      recursive: false,
                                                      position: (827, 47),
                                                     },
                                                    ],
                                                   },
                                                   BinaryOperation {
                                                    operator: Update,
                                                    operands: [
                                                     FunctionApplication {
                                                      function: Variable {
                                                       identifier: "optionalAttrs",
                                                       position: (828, 10),
                                                      },
                                                      arguments: [
                                                       BinaryOperation {
                                                        operator: NotEqualTo,
                                                        operands: [
                                                         PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "cfg",
                                                           position: (828, 25),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "tlsTrustedAuthorities",
                                                             position: (828, 29),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                         String {
                                                          parts: [],
                                                         },
                                                        ],
                                                        position: (828, 51),
                                                       },
                                                       Map {
                                                        bindings: [
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtp_tls_CAfile",
                                                             position: (829, 9),
                                                            },
                                                           ],
                                                          },
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "cfg",
                                                            position: (829, 27),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "tlsTrustedAuthorities",
                                                              position: (829, 31),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtp_tls_security_level",
                                                             position: (830, 9),
                                                            },
                                                           ],
                                                          },
                                                          FunctionApplication {
                                                           function: Variable {
                                                            identifier: "mkDefault",
                                                            position: (830, 35),
                                                           },
                                                           arguments: [
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "may",
                                                               position: (830, 46),
                                                              },
                                                             ],
                                                            },
                                                           ],
                                                          },
                                                         ),
                                                        ],
                                                        recursive: false,
                                                        position: (828, 58),
                                                       },
                                                      ],
                                                     },
                                                     FunctionApplication {
                                                      function: Variable {
                                                       identifier: "optionalAttrs",
                                                       position: (832, 10),
                                                      },
                                                      arguments: [
                                                       BinaryOperation {
                                                        operator: NotEqualTo,
                                                        operands: [
                                                         PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "cfg",
                                                           position: (832, 25),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "sslCert",
                                                             position: (832, 29),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                         String {
                                                          parts: [],
                                                         },
                                                        ],
                                                        position: (832, 37),
                                                       },
                                                       Map {
                                                        bindings: [
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtp_tls_cert_file",
                                                             position: (833, 9),
                                                            },
                                                           ],
                                                          },
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "cfg",
                                                            position: (833, 30),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "sslCert",
                                                              position: (833, 34),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtp_tls_key_file",
                                                             position: (834, 9),
                                                            },
                                                           ],
                                                          },
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "cfg",
                                                            position: (834, 29),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "sslKey",
                                                              position: (834, 33),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtp_tls_security_level",
                                                             position: (836, 9),
                                                            },
                                                           ],
                                                          },
                                                          FunctionApplication {
                                                           function: Variable {
                                                            identifier: "mkDefault",
                                                            position: (836, 35),
                                                           },
                                                           arguments: [
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "may",
                                                               position: (836, 46),
                                                              },
                                                             ],
                                                            },
                                                           ],
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtpd_tls_cert_file",
                                                             position: (838, 9),
                                                            },
                                                           ],
                                                          },
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "cfg",
                                                            position: (838, 31),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "sslCert",
                                                              position: (838, 35),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtpd_tls_key_file",
                                                             position: (839, 9),
                                                            },
                                                           ],
                                                          },
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "cfg",
                                                            position: (839, 30),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "sslKey",
                                                              position: (839, 34),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ),
                                                         KeyValue(
                                                          AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "smtpd_tls_security_level",
                                                             position: (841, 9),
                                                            },
                                                           ],
                                                          },
                                                          String {
                                                           parts: [
                                                            Raw {
                                                             content: "may",
                                                             position: (841, 37),
                                                            },
                                                           ],
                                                          },
                                                         ),
                                                        ],
                                                        recursive: false,
                                                        position: (832, 44),
                                                       },
                                                      ],
                                                     },
                                                    ],
                                                    position: (832, 7),
                                                   },
                                                  ],
                                                  position: (828, 7),
                                                 },
                                                ],
                                                position: (827, 7),
                                               },
                                              ],
                                              position: (821, 7),
                                             },
                                            ],
                                            position: (820, 7),
                                           },
                                          ],
                                          position: (819, 7),
                                         },
                                        ],
                                        position: (818, 7),
                                       },
                                      ],
                                      position: (817, 7),
                                     },
                                    ],
                                    position: (816, 7),
                                   },
                                  ],
                                  position: (815, 7),
                                 },
                                ],
                                position: (814, 7),
                               },
                              ],
                              position: (813, 7),
                             },
                            ],
                            position: (812, 7),
                           },
                          ],
                          position: (811, 7),
                         },
                        ],
                        position: (810, 7),
                       },
                      ],
                      position: (809, 7),
                     },
                    ],
                    position: (808, 7),
                   },
                  ],
                  position: (807, 7),
                 },
                ],
                position: (804, 7),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (844, 7),
                 },
                 Raw {
                  content: "postfix",
                  position: (844, 16),
                 },
                 Raw {
                  content: "masterConfig",
                  position: (844, 24),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "pickup",
                       position: (845, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "private",
                          position: (846, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (846, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeup",
                          position: (847, 11),
                         },
                        ],
                       },
                       Int {
                        value: 60,
                        position: (847, 20),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (848, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (848, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (845, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "cleanup",
                       position: (850, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "private",
                          position: (851, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (851, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (852, 11),
                         },
                        ],
                       },
                       Int {
                        value: 0,
                        position: (852, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (850, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "qmgr",
                       position: (854, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "private",
                          position: (855, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (855, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeup",
                          position: (856, 11),
                         },
                        ],
                       },
                       Int {
                        value: 300,
                        position: (856, 20),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (857, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (857, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (854, 16),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "tlsmgr",
                       position: (859, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeup",
                          position: (860, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1000,
                        position: (860, 20),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeupUnusedComponent",
                          position: (861, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (861, 35),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (862, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (862, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (859, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "rewrite",
                       position: (864, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (865, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "trivial-rewrite",
                          position: (865, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (864, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "bounce",
                       position: (867, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (868, 11),
                         },
                        ],
                       },
                       Int {
                        value: 0,
                        position: (868, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (867, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defer",
                       position: (870, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (871, 11),
                         },
                        ],
                       },
                       Int {
                        value: 0,
                        position: (871, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (872, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "bounce",
                          position: (872, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (870, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "trace",
                       position: (874, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (875, 11),
                         },
                        ],
                       },
                       Int {
                        value: 0,
                        position: (875, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (876, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "bounce",
                          position: (876, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (874, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "verify",
                       position: (878, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (879, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (879, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (878, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "flush",
                       position: (881, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "private",
                          position: (882, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (882, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeup",
                          position: (883, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1000,
                        position: (883, 20),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "wakeupUnusedComponent",
                          position: (884, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (884, 35),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (885, 11),
                         },
                        ],
                       },
                       Int {
                        value: 0,
                        position: (885, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (881, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "proxymap",
                       position: (887, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (888, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "proxymap",
                          position: (888, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (887, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "proxywrite",
                       position: (890, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (891, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (891, 21),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (892, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "proxymap",
                          position: (892, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (890, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "showq",
                       position: (894, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "private",
                          position: (895, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (895, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (894, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "error",
                       position: (897, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [],
                     recursive: false,
                     position: (897, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "retry",
                       position: (898, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "command",
                          position: (899, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "error",
                          position: (899, 22),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (898, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "discard",
                       position: (901, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [],
                     recursive: false,
                     position: (901, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "local",
                       position: (902, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "privileged",
                          position: (903, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "true",
                        position: (903, 24),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (902, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "virtual",
                       position: (905, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "privileged",
                          position: (906, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "true",
                        position: (906, 24),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (905, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "lmtp",
                       position: (908, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [],
                     recursive: false,
                     position: (908, 16),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "anvil",
                       position: (910, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (911, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (911, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (910, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "scache",
                       position: (913, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "maxproc",
                          position: (914, 11),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (914, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (913, 18),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (844, 39),
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "optionalAttrs",
                     position: (916, 12),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (916, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "enableSubmission",
                         position: (916, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "submission",
                           position: (917, 9),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (918, 11),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "inet",
                              position: (918, 19),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "private",
                              position: (919, 11),
                             },
                            ],
                           },
                           Variable {
                            identifier: "false",
                            position: (919, 21),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "command",
                              position: (920, 11),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "smtpd",
                              position: (920, 22),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "args",
                              position: (921, 11),
                             },
                            ],
                           },
                           LetIn {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "mkKeyVal",
                                 position: (922, 13),
                                },
                               ],
                              },
                              Function {
                               argument: Some(
                                "opt",
                               ),
                               arguments: FunctionArguments {
                                arguments: [],
                                ellipsis: false,
                               },
                               definition: Function {
                                argument: Some(
                                 "val",
                                ),
                                arguments: FunctionArguments {
                                 arguments: [],
                                 ellipsis: false,
                                },
                                definition: List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "-o",
                                     position: (922, 37),
                                    },
                                   ],
                                  },
                                  BinaryOperation {
                                   operator: Addition,
                                   operands: [
                                    BinaryOperation {
                                     operator: Addition,
                                     operands: [
                                      Variable {
                                       identifier: "opt",
                                       position: (922, 42),
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "=",
                                         position: (922, 49),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (922, 46),
                                    },
                                    Variable {
                                     identifier: "val",
                                     position: (922, 54),
                                    },
                                   ],
                                   position: (922, 52),
                                  },
                                 ],
                                 position: (922, 34),
                                },
                                position: (922, 29),
                               },
                               position: (922, 24),
                              },
                             ),
                            ],
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "concatLists",
                              position: (923, 14),
                             },
                             arguments: [
                              FunctionApplication {
                               function: Variable {
                                identifier: "mapAttrsToList",
                                position: (923, 27),
                               },
                               arguments: [
                                Variable {
                                 identifier: "mkKeyVal",
                                 position: (923, 42),
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (923, 51),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "submissionOptions",
                                    position: (923, 55),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ],
                            },
                            position: (921, 18),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (917, 22),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (916, 47),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionalAttrs",
                       position: (925, 12),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (925, 26),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enableSmtp",
                           position: (925, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "smtp_inet",
                             position: (926, 9),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "name",
                                position: (927, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "smtp",
                                position: (927, 19),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (928, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "inet",
                                position: (928, 19),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "private",
                                position: (929, 11),
                               },
                              ],
                             },
                             Variable {
                              identifier: "false",
                              position: (929, 21),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "command",
                                position: (930, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "smtpd",
                                position: (930, 22),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (926, 21),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "smtp",
                             position: (932, 9),
                            },
                           ],
                          },
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (932, 16),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "relay",
                             position: (933, 9),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "command",
                                position: (934, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "smtp",
                                position: (934, 22),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "args",
                                position: (935, 11),
                               },
                              ],
                             },
                             List {
                              elements: [
                               String {
                                parts: [
                                 Raw {
                                  content: "-o",
                                  position: (935, 21),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "smtp_fallback_relay=",
                                  position: (935, 26),
                                 },
                                ],
                               },
                              ],
                              position: (935, 18),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (933, 17),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (925, 41),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionalAttrs",
                       position: (937, 12),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (937, 26),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enableSubmissions",
                           position: (937, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "submissions",
                             position: (938, 9),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (939, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "inet",
                                position: (939, 19),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "private",
                                position: (940, 11),
                               },
                              ],
                             },
                             Variable {
                              identifier: "false",
                              position: (940, 21),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "command",
                                position: (941, 11),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "smtpd",
                                position: (941, 22),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "args",
                                position: (942, 11),
                               },
                              ],
                             },
                             LetIn {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "mkKeyVal",
                                   position: (943, 13),
                                  },
                                 ],
                                },
                                Function {
                                 argument: Some(
                                  "opt",
                                 ),
                                 arguments: FunctionArguments {
                                  arguments: [],
                                  ellipsis: false,
                                 },
                                 definition: Function {
                                  argument: Some(
                                   "val",
                                  ),
                                  arguments: FunctionArguments {
                                   arguments: [],
                                   ellipsis: false,
                                  },
                                  definition: List {
                                   elements: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "-o",
                                       position: (943, 37),
                                      },
                                     ],
                                    },
                                    BinaryOperation {
                                     operator: Addition,
                                     operands: [
                                      BinaryOperation {
                                       operator: Addition,
                                       operands: [
                                        Variable {
                                         identifier: "opt",
                                         position: (943, 42),
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "=",
                                           position: (943, 49),
                                          },
                                         ],
                                        },
                                       ],
                                       position: (943, 46),
                                      },
                                      Variable {
                                       identifier: "val",
                                       position: (943, 54),
                                      },
                                     ],
                                     position: (943, 52),
                                    },
                                   ],
                                   position: (943, 34),
                                  },
                                  position: (943, 29),
                                 },
                                 position: (943, 24),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "adjustSmtpTlsSecurityLevel",
                                   position: (944, 13),
                                  },
                                 ],
                                },
                                BinaryOperation {
                                 operator: LogicalOr,
                                 operands: [
                                  BinaryOperation {
                                   operator: LogicalOr,
                                   operands: [
                                    UnaryOperation {
                                     operator: Not,
                                     operand: HasProperty {
                                      expression: PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (944, 44),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "submissionsOptions",
                                          position: (944, 48),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "smtpd_tls_security_level",
                                         position: (944, 69),
                                        },
                                       ],
                                      },
                                      position: (944, 67),
                                     },
                                     position: (944, 42),
                                    },
                                    BinaryOperation {
                                     operator: EqualTo,
                                     operands: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (945, 39),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "submissionsOptions",
                                          position: (945, 43),
                                         },
                                         Raw {
                                          content: "smtpd_tls_security_level",
                                          position: (945, 62),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "none",
                                         position: (945, 91),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (945, 87),
                                    },
                                   ],
                                   position: (944, 95),
                                  },
                                  BinaryOperation {
                                   operator: EqualTo,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (946, 39),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "submissionsOptions",
                                        position: (946, 43),
                                       },
                                       Raw {
                                        content: "smtpd_tls_security_level",
                                        position: (946, 62),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "may",
                                       position: (946, 91),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (946, 87),
                                  },
                                 ],
                                 position: (945, 97),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "submissionsOptions",
                                   position: (947, 13),
                                  },
                                 ],
                                },
                                BinaryOperation {
                                 operator: Update,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (947, 34),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "submissionsOptions",
                                      position: (947, 38),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  BinaryOperation {
                                   operator: Update,
                                   operands: [
                                    Map {
                                     bindings: [
                                      KeyValue(
                                       AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "smtpd_tls_wrappermode",
                                          position: (948, 15),
                                         },
                                        ],
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "yes",
                                          position: (948, 40),
                                         },
                                        ],
                                       },
                                      ),
                                     ],
                                     recursive: false,
                                     position: (947, 60),
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optionalAttrs",
                                      position: (949, 18),
                                     },
                                     arguments: [
                                      Variable {
                                       identifier: "adjustSmtpTlsSecurityLevel",
                                       position: (949, 32),
                                      },
                                      Map {
                                       bindings: [
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "smtpd_tls_security_level",
                                            position: (950, 15),
                                           },
                                          ],
                                         },
                                         String {
                                          parts: [
                                           Raw {
                                            content: "encrypt",
                                            position: (950, 43),
                                           },
                                          ],
                                         },
                                        ),
                                       ],
                                       recursive: false,
                                       position: (949, 59),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (949, 15),
                                  },
                                 ],
                                 position: (947, 57),
                                },
                               ),
                              ],
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "concatLists",
                                position: (952, 14),
                               },
                               arguments: [
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "mapAttrsToList",
                                  position: (952, 27),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "mkKeyVal",
                                   position: (952, 42),
                                  },
                                  Variable {
                                   identifier: "submissionsOptions",
                                   position: (952, 51),
                                  },
                                 ],
                                },
                               ],
                              },
                              position: (942, 18),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (938, 23),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (937, 48),
                       },
                      ],
                     },
                    ],
                    position: (937, 9),
                   },
                  ],
                  position: (925, 9),
                 },
                ],
                position: (916, 9),
               },
              ),
             ],
             recursive: false,
             position: (663, 5),
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (957, 6),
             },
             arguments: [
              Variable {
               identifier: "haveAliases",
               position: (957, 11),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (958, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (958, 16),
                   },
                   Raw {
                    content: "aliasFiles",
                    position: (958, 24),
                   },
                   Raw {
                    content: "aliases",
                    position: (958, 35),
                   },
                  ],
                 },
                 Variable {
                  identifier: "aliasesFile",
                  position: (958, 45),
                 },
                ),
               ],
               recursive: false,
               position: (957, 23),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (960, 6),
             },
             arguments: [
              Variable {
               identifier: "haveCanonical",
               position: (960, 11),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (961, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (961, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (961, 24),
                   },
                   Raw {
                    content: "canonical",
                    position: (961, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "canonicalFile",
                  position: (961, 45),
                 },
                ),
               ],
               recursive: false,
               position: (960, 25),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (963, 6),
             },
             arguments: [
              Variable {
               identifier: "haveTransport",
               position: (963, 11),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (964, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (964, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (964, 24),
                   },
                   Raw {
                    content: "transport",
                    position: (964, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "transportFile",
                  position: (964, 45),
                 },
                ),
               ],
               recursive: false,
               position: (963, 25),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (966, 6),
             },
             arguments: [
              Variable {
               identifier: "haveVirtual",
               position: (966, 11),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (967, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (967, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (967, 24),
                   },
                   Raw {
                    content: "virtual",
                    position: (967, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "virtualFile",
                  position: (967, 43),
                 },
                ),
               ],
               recursive: false,
               position: (966, 23),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (969, 6),
             },
             arguments: [
              Variable {
               identifier: "haveLocalRecipients",
               position: (969, 11),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (970, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (970, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (970, 24),
                   },
                   Raw {
                    content: "local_recipients",
                    position: (970, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "localRecipientMapFile",
                  position: (970, 52),
                 },
                ),
               ],
               recursive: false,
               position: (969, 31),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (972, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (972, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enableHeaderChecks",
                  position: (972, 15),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (973, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (973, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (973, 24),
                   },
                   Raw {
                    content: "header_checks",
                    position: (973, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "headerChecksFile",
                  position: (973, 49),
                 },
                ),
               ],
               recursive: false,
               position: (972, 34),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (975, 6),
             },
             arguments: [
              BinaryOperation {
               operator: NotEqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (975, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dnsBlacklists",
                    position: (975, 16),
                   },
                  ],
                 },
                 default: None,
                },
                List {
                 elements: [],
                 position: (975, 33),
                },
               ],
               position: (975, 30),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (976, 7),
                   },
                   Raw {
                    content: "postfix",
                    position: (976, 16),
                   },
                   Raw {
                    content: "mapFiles",
                    position: (976, 24),
                   },
                   Raw {
                    content: "client_access",
                    position: (976, 33),
                   },
                  ],
                 },
                 Variable {
                  identifier: "checkClientAccessFile",
                  position: (976, 49),
                 },
                ),
               ],
               recursive: false,
               position: (975, 37),
              },
             ],
            },
           ],
           position: (662, 57),
          },
         ],
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (980, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (981, 5),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (981, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "postfix",
               position: (981, 41),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sslCACert",
               position: (981, 51),
              },
             ],
            },
           ],
           position: (981, 27),
          },
          String {
           parts: [
            Raw {
             content: "services.postfix.sslCACert was replaced by services.postfix.tlsTrustedAuthorities. In case you intend that your server should validate requested client certificates use services.postfix.extraConfig.",
             position: (982, 7),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkChangedOptionModule",
          position: (984, 5),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (984, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "postfix",
               position: (984, 41),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "useDane",
               position: (984, 51),
              },
             ],
            },
           ],
           position: (984, 27),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (985, 9),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "postfix",
               position: (985, 20),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "config",
               position: (985, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "smtp_tls_security_level",
               position: (985, 39),
              },
             ],
            },
           ],
           position: (985, 6),
          },
          Function {
           argument: Some(
            "config",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (986, 15),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (986, 20),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "services",
                 position: (986, 27),
                },
                Raw {
                 content: "postfix",
                 position: (986, 36),
                },
                Raw {
                 content: "useDane",
                 position: (986, 44),
                },
               ],
              },
              default: None,
             },
             String {
              parts: [
               Raw {
                content: "dane",
                position: (986, 53),
               },
              ],
             },
            ],
           },
           position: (986, 7),
          },
         ],
        },
       ],
       position: (980, 13),
      },
     ),
    ],
    recursive: false,
    position: (259, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}