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