---
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: (7, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "menuBuilderGrub2",
        position: (18, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "defaults",
      },
      definition: Function {
       argument: Simple {
        identifier: "options",
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (19, 22),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "concatStrings",
            position: (19, 26),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (21, 7),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "option",
              },
              definition: String {
               parts: [
                Raw {
                 content: "menuentry ",
                 position: (23, 1),
                },
                Raw {
                 content: "'",
                 position: (23, 19),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "defaults",
                   position: (23, 22),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "name",
                     position: (23, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " ",
                 position: (23, 36),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "option",
                   position: (25, 9),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "name",
                     position: (25, 16),
                    },
                   ],
                  },
                  default: Some(
                   Parentheses {
                    expression: IfThenElse {
                     predicate: HasProperty {
                      expression: Variable {
                       identifier: "option",
                       position: (25, 28),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "params",
                         position: (25, 37),
                        },
                       ],
                      },
                      position: (25, 35),
                     },
                     then: String {
                      parts: [
                       Raw {
                        content: "(",
                        position: (25, 50),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "option",
                          position: (25, 53),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "params",
                            position: (25, 60),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: ")",
                        position: (25, 67),
                       },
                      ],
                      position: (25, 49),
                     },
                     else_: String {
                      parts: [],
                      position: (25, 75),
                     },
                     position: (25, 25),
                    },
                    position: (25, 24),
                   },
                  ),
                 },
                },
                Raw {
                 content: "' ",
                 position: (26, 10),
                },
                Expression {
                 expression: IfThenElse {
                  predicate: HasProperty {
                   expression: Variable {
                    identifier: "option",
                    position: (26, 17),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "class",
                      position: (26, 26),
                     },
                    ],
                   },
                   position: (26, 24),
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: " --class ",
                     position: (26, 38),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "option",
                       position: (26, 49),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "class",
                         position: (26, 56),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                   ],
                   position: (26, 37),
                  },
                  else_: String {
                   parts: [],
                   position: (26, 69),
                  },
                  position: (26, 14),
                 },
                },
                Raw {
                 content: " {\n  linux ",
                 position: (26, 72),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "defaults",
                   position: (27, 19),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "image",
                     position: (27, 28),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " \\",
                 position: (27, 34),
                },
                Raw {
                 content: "$",
                 position: (27, 36),
                },
                Raw {
                 content: "{isoboot} ",
                 position: (27, 39),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "defaults",
                   position: (27, 51),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "params",
                     position: (27, 60),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " ",
                 position: (27, 67),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "option",
                   position: (28, 13),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "params",
                     position: (28, 20),
                    },
                   ],
                  },
                  default: Some(
                   String {
                    parts: [],
                    position: (28, 30),
                   },
                  ),
                 },
                },
                Raw {
                 content: "\n  initrd ",
                 position: (29, 12),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "defaults",
                   position: (30, 20),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "initrd",
                     position: (30, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\n}\n",
                 position: (30, 36),
                },
               ],
               position: (22, 16),
              },
              position: (22, 8),
             },
             position: (22, 7),
            },
            Variable {
             identifier: "options",
             position: (33, 7),
            },
           ],
          },
          position: (20, 5),
         },
        ],
       },
       position: (19, 13),
      },
      position: (19, 3),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "buildMenuGrub2",
        position: (40, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "config",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "buildMenuAdditionalParamsGrub2",
        position: (41, 5),
       },
       arguments: [
        Variable {
         identifier: "config",
         position: (41, 36),
        },
        String {
         parts: [],
         position: (41, 43),
        },
       ],
      },
      position: (40, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "buildMenuAdditionalParamsGrub2",
        position: (48, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "config",
      },
      definition: Function {
       argument: Simple {
        identifier: "additional",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "finalCfg",
             position: (50, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "name",
                position: (51, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "NixOS ",
                position: (51, 15),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (51, 23),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "system",
                    position: (51, 30),
                   },
                   Raw {
                    content: "nixos",
                    position: (51, 37),
                   },
                   Raw {
                    content: "label",
                    position: (51, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (51, 51),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "isoImage",
                    position: (51, 58),
                   },
                   Raw {
                    content: "appendToMenuLabel",
                    position: (51, 67),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
              position: (51, 14),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "params",
                position: (52, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "init=",
                position: (52, 17),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (52, 24),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "system",
                    position: (52, 31),
                   },
                   Raw {
                    content: "build",
                    position: (52, 38),
                   },
                   Raw {
                    content: "toplevel",
                    position: (52, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/init ",
                position: (52, 53),
               },
               Expression {
                expression: Variable {
                 identifier: "additional",
                 position: (52, 61),
                },
               },
               Raw {
                content: " ",
                position: (52, 72),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (52, 75),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (52, 84),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "boot",
                      position: (52, 91),
                     },
                     Raw {
                      content: "kernelParams",
                      position: (52, 96),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
              position: (52, 16),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "image",
                position: (53, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "/boot/",
                position: (53, 16),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (53, 24),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "system",
                    position: (53, 31),
                   },
                   Raw {
                    content: "boot",
                    position: (53, 38),
                   },
                   Raw {
                    content: "loader",
                    position: (53, 43),
                   },
                   Raw {
                    content: "kernelFile",
                    position: (53, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
              position: (53, 15),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "initrd",
                position: (54, 7),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "/boot/initrd",
                position: (54, 17),
               },
              ],
              position: (54, 16),
             },
            },
           ],
           recursive: false,
           position: (50, 16),
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "menuBuilderGrub2",
          position: (57, 5),
         },
         arguments: [
          Variable {
           identifier: "finalCfg",
           position: (58, 5),
          },
          List {
           elements: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "class",
                  position: (60, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "installer",
                  position: (60, 18),
                 },
                ],
                position: (60, 17),
               },
              },
             ],
             recursive: false,
             position: (60, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "class",
                  position: (61, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "nomodeset",
                  position: (61, 18),
                 },
                ],
                position: (61, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "params",
                  position: (61, 30),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "nomodeset",
                  position: (61, 40),
                 },
                ],
                position: (61, 39),
               },
              },
             ],
             recursive: false,
             position: (61, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "class",
                  position: (62, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "copytoram",
                  position: (62, 18),
                 },
                ],
                position: (62, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "params",
                  position: (62, 30),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "copytoram",
                  position: (62, 40),
                 },
                ],
                position: (62, 39),
               },
              },
             ],
             recursive: false,
             position: (62, 7),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "class",
                  position: (63, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "debug",
                  position: (63, 18),
                 },
                ],
                position: (63, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "params",
                  position: (63, 30),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "debug",
                  position: (63, 40),
                 },
                ],
                position: (63, 39),
               },
              },
             ],
             recursive: false,
             position: (63, 7),
            },
           ],
           position: (59, 5),
          },
         ],
        },
        position: (49, 3),
       },
       position: (48, 44),
      },
      position: (48, 36),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "syslinuxTimeout",
        position: (69, 3),
       },
      ],
     },
     to: IfThenElse {
      predicate: BinaryOperation {
       operator: EqualTo,
       operands: [
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (69, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (69, 31),
           },
           Raw {
            content: "loader",
            position: (69, 36),
           },
           Raw {
            content: "timeout",
            position: (69, 43),
           },
          ],
         },
         default: None,
        },
        Variable {
         identifier: "null",
         position: (69, 54),
        },
       ],
       position: (69, 51),
      },
      then: Int {
       value: 0,
       position: (70, 7),
      },
      else_: FunctionApplication {
       function: Variable {
        identifier: "max",
        position: (72, 7),
       },
       arguments: [
        Parentheses {
         expression: BinaryOperation {
          operator: Multiplication,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (72, 12),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "boot",
               position: (72, 19),
              },
              Raw {
               content: "loader",
               position: (72, 24),
              },
              Raw {
               content: "timeout",
               position: (72, 31),
              },
             ],
            },
            default: None,
           },
           Int {
            value: 10,
            position: (72, 41),
           },
          ],
          position: (72, 39),
         },
         position: (72, 11),
        },
        Int {
         value: 1,
         position: (72, 45),
        },
       ],
      },
      position: (69, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "max",
        position: (75, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "x",
      },
      definition: Function {
       argument: Simple {
        identifier: "y",
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: GreaterThan,
         operands: [
          Variable {
           identifier: "x",
           position: (75, 18),
          },
          Variable {
           identifier: "y",
           position: (75, 22),
          },
         ],
         position: (75, 20),
        },
        then: Variable {
         identifier: "x",
         position: (75, 29),
        },
        else_: Variable {
         identifier: "y",
         position: (75, 36),
        },
        position: (75, 15),
       },
       position: (75, 12),
      },
      position: (75, 9),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "baseIsolinuxCfg",
        position: (90, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "SERIAL 0 115200\nTIMEOUT ",
        position: (91, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "builtins",
           position: (92, 15),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "toString",
             position: (92, 24),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "syslinuxTimeout",
           position: (92, 33),
          },
         ],
        },
       },
       Raw {
        content: "\nUI vesamenu.c32\nMENU BACKGROUND /isolinux/background.png\n\n",
        position: (92, 49),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (96, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (96, 14),
           },
           Raw {
            content: "syslinuxTheme",
            position: (96, 23),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\nDEFAULT boot\n\nLABEL boot\nMENU LABEL NixOS ",
        position: (96, 37),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (101, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (101, 31),
           },
           Raw {
            content: "nixos",
            position: (101, 38),
           },
           Raw {
            content: "label",
            position: (101, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (101, 52),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (101, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (101, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nLINUX /boot/",
        position: (101, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (102, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (102, 26),
           },
           Raw {
            content: "boot",
            position: (102, 33),
           },
           Raw {
            content: "loader",
            position: (102, 38),
           },
           Raw {
            content: "kernelFile",
            position: (102, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (102, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (103, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (103, 26),
           },
           Raw {
            content: "build",
            position: (103, 33),
           },
           Raw {
            content: "toplevel",
            position: (103, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (103, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (103, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (103, 65),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (103, 72),
             },
             Raw {
              content: "kernelParams",
              position: (103, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: "\nINITRD /boot/",
        position: (103, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (104, 20),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (104, 27),
           },
           Raw {
            content: "boot",
            position: (104, 34),
           },
           Raw {
            content: "loader",
            position: (104, 39),
           },
           Raw {
            content: "initrdFile",
            position: (104, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with 'nomodeset'\nLABEL boot-nomodeset\nMENU LABEL NixOS ",
        position: (104, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (108, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (108, 31),
           },
           Raw {
            content: "nixos",
            position: (108, 38),
           },
           Raw {
            content: "label",
            position: (108, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (108, 52),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (108, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (108, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (nomodeset)\nLINUX /boot/",
        position: (108, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (109, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (109, 26),
           },
           Raw {
            content: "boot",
            position: (109, 33),
           },
           Raw {
            content: "loader",
            position: (109, 38),
           },
           Raw {
            content: "kernelFile",
            position: (109, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (109, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (110, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (110, 26),
           },
           Raw {
            content: "build",
            position: (110, 33),
           },
           Raw {
            content: "toplevel",
            position: (110, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (110, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (110, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (110, 65),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (110, 72),
             },
             Raw {
              content: "kernelParams",
              position: (110, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " nomodeset\nINITRD /boot/",
        position: (110, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (111, 20),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (111, 27),
           },
           Raw {
            content: "boot",
            position: (111, 34),
           },
           Raw {
            content: "loader",
            position: (111, 39),
           },
           Raw {
            content: "initrdFile",
            position: (111, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with 'copytoram'\nLABEL boot-copytoram\nMENU LABEL NixOS ",
        position: (111, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (115, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (115, 31),
           },
           Raw {
            content: "nixos",
            position: (115, 38),
           },
           Raw {
            content: "label",
            position: (115, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (115, 52),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (115, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (115, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (copytoram)\nLINUX /boot/",
        position: (115, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (116, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (116, 26),
           },
           Raw {
            content: "boot",
            position: (116, 33),
           },
           Raw {
            content: "loader",
            position: (116, 38),
           },
           Raw {
            content: "kernelFile",
            position: (116, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (116, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (117, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (117, 26),
           },
           Raw {
            content: "build",
            position: (117, 33),
           },
           Raw {
            content: "toplevel",
            position: (117, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (117, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (117, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (117, 65),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (117, 72),
             },
             Raw {
              content: "kernelParams",
              position: (117, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " copytoram\nINITRD /boot/",
        position: (117, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (118, 20),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (118, 27),
           },
           Raw {
            content: "boot",
            position: (118, 34),
           },
           Raw {
            content: "loader",
            position: (118, 39),
           },
           Raw {
            content: "initrdFile",
            position: (118, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with verbose logging to the console\nLABEL boot-debug\nMENU LABEL NixOS ",
        position: (118, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (122, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (122, 31),
           },
           Raw {
            content: "nixos",
            position: (122, 38),
           },
           Raw {
            content: "label",
            position: (122, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (122, 52),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (122, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (122, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (debug)\nLINUX /boot/",
        position: (122, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (123, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (123, 26),
           },
           Raw {
            content: "boot",
            position: (123, 33),
           },
           Raw {
            content: "loader",
            position: (123, 38),
           },
           Raw {
            content: "kernelFile",
            position: (123, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (123, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (124, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (124, 26),
           },
           Raw {
            content: "build",
            position: (124, 33),
           },
           Raw {
            content: "toplevel",
            position: (124, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (124, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (124, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (124, 65),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (124, 72),
             },
             Raw {
              content: "kernelParams",
              position: (124, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " loglevel=7\nINITRD /boot/",
        position: (124, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (125, 20),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (125, 27),
           },
           Raw {
            content: "boot",
            position: (125, 34),
           },
           Raw {
            content: "loader",
            position: (125, 39),
           },
           Raw {
            content: "initrdFile",
            position: (125, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with a serial console enabled\nLABEL boot-serial\nMENU LABEL NixOS ",
        position: (125, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (129, 24),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (129, 31),
           },
           Raw {
            content: "nixos",
            position: (129, 38),
           },
           Raw {
            content: "label",
            position: (129, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (129, 52),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (129, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (129, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (serial console=ttyS0,115200n8)\nLINUX /boot/",
        position: (129, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (130, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (130, 26),
           },
           Raw {
            content: "boot",
            position: (130, 33),
           },
           Raw {
            content: "loader",
            position: (130, 38),
           },
           Raw {
            content: "kernelFile",
            position: (130, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (130, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (131, 19),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (131, 26),
           },
           Raw {
            content: "build",
            position: (131, 33),
           },
           Raw {
            content: "toplevel",
            position: (131, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (131, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (131, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (131, 65),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (131, 72),
             },
             Raw {
              content: "kernelParams",
              position: (131, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " console=ttyS0,115200n8\nINITRD /boot/",
        position: (131, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (132, 20),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (132, 27),
           },
           Raw {
            content: "boot",
            position: (132, 34),
           },
           Raw {
            content: "loader",
            position: (132, 39),
           },
           Raw {
            content: "initrdFile",
            position: (132, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n",
        position: (132, 57),
       },
      ],
      position: (90, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isolinuxMemtest86Entry",
        position: (135, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "LABEL memtest\nMENU LABEL Memtest86+\nLINUX /boot/memtest.bin\nAPPEND ",
        position: (136, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (139, 14),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (139, 23),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (139, 30),
             },
             Raw {
              content: "loader",
              position: (139, 35),
             },
             Raw {
              content: "grub",
              position: (139, 42),
             },
             Raw {
              content: "memtest86",
              position: (139, 47),
             },
             Raw {
              content: "params",
              position: (139, 57),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: "\n",
        position: (139, 64),
       },
      ],
      position: (135, 28),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isolinuxCfg",
        position: (142, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (142, 17),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "\n",
          position: (142, 35),
         },
        ],
        position: (142, 34),
       },
       Parentheses {
        expression: BinaryOperation {
         operator: Concatenation,
         operands: [
          List {
           elements: [
            Variable {
             identifier: "baseIsolinuxCfg",
             position: (143, 8),
            },
           ],
           position: (143, 6),
          },
          FunctionApplication {
           function: Variable {
            identifier: "optional",
            position: (143, 29),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (143, 38),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "boot",
                position: (143, 45),
               },
               Raw {
                content: "loader",
                position: (143, 50),
               },
               Raw {
                content: "grub",
                position: (143, 57),
               },
               Raw {
                content: "memtest86",
                position: (143, 62),
               },
               Raw {
                content: "enable",
                position: (143, 72),
               },
              ],
             },
             default: None,
            },
            Variable {
             identifier: "isolinuxMemtest86Entry",
             position: (143, 79),
            },
           ],
          },
         ],
         position: (143, 26),
        },
        position: (143, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "refindBinary",
        position: (145, 3),
       },
      ],
     },
     to: IfThenElse {
      predicate: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "targetArch",
           position: (145, 21),
          },
          String {
           parts: [
            Raw {
             content: "x64",
             position: (145, 36),
            },
           ],
           position: (145, 35),
          },
         ],
         position: (145, 32),
        },
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "targetArch",
           position: (145, 44),
          },
          String {
           parts: [
            Raw {
             content: "aa64",
             position: (145, 59),
            },
           ],
           position: (145, 58),
          },
         ],
         position: (145, 55),
        },
       ],
       position: (145, 41),
      },
      then: String {
       parts: [
        Raw {
         content: "refind_",
         position: (145, 71),
        },
        Expression {
         expression: Variable {
          identifier: "targetArch",
          position: (145, 80),
         },
        },
        Raw {
         content: ".efi",
         position: (145, 91),
        },
       ],
       position: (145, 70),
      },
      else_: Variable {
       identifier: "null",
       position: (145, 102),
      },
      position: (145, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "refind",
        position: (148, 3),
       },
      ],
     },
     to: IfThenElse {
      predicate: BinaryOperation {
       operator: NotEqualTo,
       operands: [
        Variable {
         identifier: "refindBinary",
         position: (149, 8),
        },
        Variable {
         identifier: "null",
         position: (149, 24),
        },
       ],
       position: (149, 21),
      },
      then: String {
       parts: [
        Raw {
         content: "# Adds rEFInd to the ISO.\ncp -v ",
         position: (151, 1),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (152, 15),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "refind",
             position: (152, 20),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "/share/refind/",
         position: (152, 27),
        },
        Expression {
         expression: Variable {
          identifier: "refindBinary",
          position: (152, 43),
         },
        },
        Raw {
         content: " $out/EFI/boot/\n",
         position: (152, 56),
        },
       ],
       position: (150, 7),
      },
      else_: String {
       parts: [
        Raw {
         content: "# No refind for ",
         position: (155, 8),
        },
        Expression {
         expression: Variable {
          identifier: "targetArch",
          position: (155, 26),
         },
        },
       ],
       position: (155, 7),
      },
      position: (149, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "grubPkgs",
        position: (158, 3),
       },
      ],
     },
     to: IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (158, 17),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "boot",
          position: (158, 24),
         },
         Raw {
          content: "loader",
          position: (158, 29),
         },
         Raw {
          content: "grub",
          position: (158, 36),
         },
         Raw {
          content: "forcei686",
          position: (158, 41),
         },
        ],
       },
       default: None,
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (158, 56),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "pkgsi686Linux",
          position: (158, 61),
         },
        ],
       },
       default: None,
      },
      else_: Variable {
       identifier: "pkgs",
       position: (158, 80),
      },
      position: (158, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "grubMenuCfg",
        position: (160, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "#\n# Menu configuration\n#\n\n# Search using a \"marker file\"\nsearch --set=root --file /EFI/nixos-installer-image\n\ninsmod gfxterm\ninsmod png\nset gfxpayload=keep\nset gfxmode=",
        position: (161, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (171, 19),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: ",",
             position: (171, 37),
            },
           ],
           position: (171, 36),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1920x1080",
               position: (177, 8),
              },
             ],
             position: (177, 7),
            },
            String {
             parts: [
              Raw {
               content: "1366x768",
               position: (178, 8),
              },
             ],
             position: (178, 7),
            },
            String {
             parts: [
              Raw {
               content: "1280x720",
               position: (179, 8),
              },
             ],
             position: (179, 7),
            },
            String {
             parts: [
              Raw {
               content: "1024x768",
               position: (180, 8),
              },
             ],
             position: (180, 7),
            },
            String {
             parts: [
              Raw {
               content: "800x600",
               position: (181, 8),
              },
             ],
             position: (181, 7),
            },
            String {
             parts: [
              Raw {
               content: "auto",
               position: (182, 8),
              },
             ],
             position: (182, 7),
            },
           ],
           position: (171, 40),
          },
         ],
        },
       },
       Raw {
        content: "\n\n# Fonts can be loaded?\n# (This font is assumed to always be provided as a fallback by NixOS)\nif loadfont (\\$root)/EFI/boot/unicode.pf2; then\n  set with_fonts=true\nfi\nif [ \"\\$textmode\" != \"true\" -a \"\\$with_fonts\" == \"true\" ]; then\n  # Use graphical term, it can be either with background image or a theme.\n  # input is \"console\", while output is \"gfxterm\".\n  # This enables \"serial\" input and output only when possible.\n  # Otherwise the failure mode is to not even enable gfxterm.\n  if test \"\\$with_serial\" == \"yes\"; then\n    terminal_output gfxterm serial\n    terminal_input  console serial\n  else\n    terminal_output gfxterm\n    terminal_input  console\n  fi\nelse\n  # Sets colors for the non-graphical term.\n  set menu_color_normal=cyan/blue\n  set menu_color_highlight=white/blue\nfi\n\n",
        position: (183, 7),
       },
       Expression {
        expression: IfThenElse {
         predicate: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (209, 8),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "isoImage",
               position: (209, 15),
              },
              Raw {
               content: "grubTheme",
               position: (209, 24),
              },
             ],
            },
            default: None,
           },
           Variable {
            identifier: "null",
            position: (209, 37),
           },
          ],
          position: (209, 34),
         },
         then: String {
          parts: [
           Raw {
            content: "# Sets theme.\nset theme=(\\$root)/EFI/boot/grub-theme/theme.txt\n# Load theme fonts\n$(find ",
            position: (210, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (213, 16),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "isoImage",
                position: (213, 23),
               },
               Raw {
                content: "grubTheme",
                position: (213, 32),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: " -iname '*.pf2' -printf \"loadfont (\\$root)/EFI/boot/grub-theme/%P\\n\")\n",
            position: (213, 42),
           },
          ],
          position: (209, 47),
         },
         else_: String {
          parts: [
           Raw {
            content: "if background_image (\\$root)/EFI/boot/efi-background.png; then\n  # Black background means transparent background when there\n  # is a background image set... This seems undocumented :(\n  set color_normal=black/black\n  set color_highlight=white/blue\nelse\n  # Falls back again to proper colors.\n  set menu_color_normal=cyan/blue\n  set menu_color_highlight=white/blue\nfi\n",
            position: (215, 1),
           },
          ],
          position: (214, 13),
         },
         position: (209, 5),
        },
       },
       Raw {
        content: "\n",
        position: (225, 8),
       },
      ],
      position: (160, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "efiDir",
        position: (232, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (232, 12),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "runCommand",
          position: (232, 17),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "efi-directory",
          position: (232, 29),
         },
        ],
        position: (232, 28),
       },
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "nativeBuildInputs",
             position: (233, 5),
            },
           ],
          },
          to: List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (233, 27),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "buildPackages",
                position: (233, 32),
               },
               Raw {
                content: "grub2_efi",
                position: (233, 46),
               },
              ],
             },
             default: None,
            },
           ],
           position: (233, 25),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "strictDeps",
             position: (234, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (234, 18),
          },
         },
        ],
        recursive: false,
        position: (232, 44),
       },
       String {
        parts: [
         Raw {
          content: "mkdir -p $out/EFI/boot/\n\n# Add a marker so GRUB can find the filesystem.\ntouch $out/EFI/nixos-installer-image\n\n# ALWAYS required modules.\nMODULES=\"fat iso9660 part_gpt part_msdos \\\n         normal boot linux configfile loopback chain halt \\\n         efifwsetup efi_gop \\\n         ls search search_label search_fs_uuid search_fs_file \\\n         gfxmenu gfxterm gfxterm_background gfxterm_menu test all_video loadenv \\\n         exfat ext2 ntfs btrfs hfsplus udf \\\n         videoinfo png \\\n         echo serial \\\n        \"\n\necho \"Building GRUB with modules:\"\nfor mod in $MODULES; do\n  echo \" - $mod\"\ndone\n\n# Modules that may or may not be available per-platform.\necho \"Adding additional modules:\"\nfor mod in efi_uga; do\n  if [ -f ",
          position: (236, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (260, 17),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (260, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/lib/grub/",
          position: (260, 36),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (260, 48),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (260, 57),
             },
             Raw {
              content: "grubTarget",
              position: (260, 67),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/$mod.mod ]; then\n    echo \" - $mod\"\n    MODULES+=\" $mod\"\n  fi\ndone\n\n# Make our own efi program, we can't rely on \"grub-install\" since it seems to\n# probe for devices, even with --skip-fs-probe.\ngrub-mkimage --directory=",
          position: (260, 78),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (268, 32),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (268, 41),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/lib/grub/",
          position: (268, 51),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (268, 63),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (268, 72),
             },
             Raw {
              content: "grubTarget",
              position: (268, 82),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " -o $out/EFI/boot/boot",
          position: (268, 93),
         },
         Expression {
          expression: Variable {
           identifier: "targetArch",
           position: (268, 117),
          },
         },
         Raw {
          content: ".efi -p /EFI/boot -O ",
          position: (268, 128),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (268, 151),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (268, 160),
             },
             Raw {
              content: "grubTarget",
              position: (268, 170),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " \\\n  $MODULES\ncp ",
          position: (268, 181),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (270, 10),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "grub2_efi",
              position: (270, 19),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/share/grub/unicode.pf2 $out/EFI/boot/\n\ncat <<EOF > $out/EFI/boot/grub.cfg\n\nset with_fonts=false\nset textmode=false\n# If you want to use serial for \"terminal_*\" commands, you need to set one up:\n#   Example manual configuration:\n#    → serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n# This uses the defaults, and makes the serial terminal available.\nset with_serial=no\nif serial; then set with_serial=yes ;fi\nexport with_serial\nclear\nset timeout=10\n\n# This message will only be viewable when \"gfxterm\" is not used.\necho \"\"\necho \"Loading graphical boot menu...\"\necho \"\"\necho \"Press 't' to use the text boot menu on this console...\"\necho \"\"\n\n",
          position: (270, 29),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (293, 7),
          },
         },
         Raw {
          content: "\n\nhiddenentry 'Text mode' --hotkey 't' {\n  loadfont (\\$root)/EFI/boot/unicode.pf2\n  set textmode=true\n  terminal_output gfxterm console\n}\nhiddenentry 'GUI mode' --hotkey 'g' {\n  $(find ",
          position: (293, 19),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (301, 16),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "isoImage",
              position: (301, 23),
             },
             Raw {
              content: "grubTheme",
              position: (301, 32),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " -iname '*.pf2' -printf \"loadfont (\\$root)/EFI/boot/grub-theme/%P\\n\")\n  set textmode=false\n  terminal_output gfxterm\n}\n\n\n# If the parameter iso_path is set, append the findiso parameter to the kernel\n# line. We need this to allow the nixos iso to be booted from grub directly.\nif [ \\",
          position: (301, 42),
         },
         Raw {
          content: "$",
          position: (309, 11),
         },
         Raw {
          content: "{iso_path} ] ; then\n  set isoboot=\"findiso=\\",
          position: (309, 14),
         },
         Raw {
          content: "$",
          position: (310, 29),
         },
         Raw {
          content: "{iso_path}\"\nfi\n\n#\n# Menu entries\n#\n\n",
          position: (310, 32),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuGrub2",
            position: (317, 7),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (317, 22),
            },
           ],
          },
         },
         Raw {
          content: "\nsubmenu \"HiDPI, Quirks and Accessibility\" --class hidpi --class submenu {\n  ",
          position: (317, 29),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (319, 9),
          },
         },
         Raw {
          content: "\n  submenu \"Suggests resolution @720p\" --class hidpi-720p {\n    ",
          position: (319, 21),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (321, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (321, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (322, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (322, 42),
            },
            String {
             parts: [
              Raw {
               content: "video=1280x720@60",
               position: (322, 50),
              },
             ],
             position: (322, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Suggests resolution @1080p\" --class hidpi-1080p {\n    ",
          position: (322, 69),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (325, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (325, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (326, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (326, 42),
            },
            String {
             parts: [
              Raw {
               content: "video=1920x1080@60",
               position: (326, 50),
              },
             ],
             position: (326, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # If we boot into a graphical environment where X is autoran\n  # and always crashes, it makes the media unusable. Allow the user\n  # to disable this.\n  submenu \"Disable display-manager\" --class quirk-disable-displaymanager {\n    ",
          position: (326, 70),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (333, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (333, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (334, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (334, 42),
            },
            String {
             parts: [
              Raw {
               content: "systemd.mask=display-manager.service",
               position: (334, 50),
              },
             ],
             position: (334, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # Some laptop and convertibles have the panel installed in an\n  # inconvenient way, rotated away from the keyboard.\n  # Those entries makes it easier to use the installer.\n  submenu \"\" {return}\n  submenu \"Rotate framebuffer Clockwise\" --class rotate-90cw {\n    ",
          position: (334, 88),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (342, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (342, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (343, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (343, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:1",
               position: (343, 50),
              },
             ],
             position: (343, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Rotate framebuffer Upside-Down\" --class rotate-180 {\n    ",
          position: (343, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (346, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (346, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (347, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (347, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:2",
               position: (347, 50),
              },
             ],
             position: (347, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Rotate framebuffer Counter-Clockwise\" --class rotate-90ccw {\n    ",
          position: (347, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (350, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (350, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (351, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (351, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:3",
               position: (351, 50),
              },
             ],
             position: (351, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # As a proof of concept, mainly. (Not sure it has accessibility merits.)\n  submenu \"\" {return}\n  submenu \"Use black on white\" --class accessibility-blakconwhite {\n    ",
          position: (351, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (357, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (357, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (358, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (358, 42),
            },
            String {
             parts: [
              Raw {
               content: "vt.default_red=0xFF,0xBC,0x4F,0xB4,0x56,0xBC,0x4F,0x00,0xA1,0xCF,0x84,0xCA,0x8D,0xB4,0x84,0x68 vt.default_grn=0xFF,0x55,0xBA,0xBA,0x4D,0x4D,0xB3,0x00,0xA0,0x8F,0xB3,0xCA,0x88,0x93,0xA4,0x68 vt.default_blu=0xFF,0x58,0x5F,0x58,0xC5,0xBD,0xC5,0x00,0xA8,0xBB,0xAB,0x97,0xBD,0xC7,0xC5,0x68",
               position: (358, 50),
              },
             ],
             position: (358, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # Serial access is a must!\n  submenu \"\" {return}\n  submenu \"Serial console=ttyS0,115200n8\" --class serial {\n    ",
          position: (358, 336),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (364, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (364, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (365, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (365, 42),
            },
            String {
             parts: [
              Raw {
               content: "console=ttyS0,115200n8",
               position: (365, 50),
              },
             ],
             position: (365, 49),
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n}\n\n",
          position: (365, 74),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (369, 7),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "optionalString",
               position: (369, 11),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "refindBinary",
                position: (369, 27),
               },
               Variable {
                identifier: "null",
                position: (369, 43),
               },
              ],
              position: (369, 40),
             },
             position: (369, 26),
            },
            String {
             parts: [
              Raw {
               content: "# GRUB apparently cannot do \"chainloader\" operations on \"CD\".\nif [ \"\\$root\" != \"cd0\" ]; then\n  # Force root to be the FAT partition\n  # Otherwise it breaks rEFInd's boot\n  search --set=root --no-floppy --fs-uuid 1234-5678\n  menuentry 'rEFInd' --class refind {\n    chainloader (\\$root)/EFI/boot/",
               position: (370, 1),
              },
              Expression {
               expression: Variable {
                identifier: "refindBinary",
                position: (376, 41),
               },
              },
              Raw {
               content: "\n  }\nfi\n",
               position: (376, 54),
              },
             ],
             position: (369, 49),
            },
           ],
          },
         },
         Raw {
          content: "\nmenuentry 'Firmware Setup' --class settings {\n  fwsetup\n  clear\n  echo \"\"\n  echo \"If you see this message, your EFI system doesn't support this feature.\"\n  echo \"\"\n}\nmenuentry 'Shutdown' --class shutdown {\n  halt\n}\nEOF\n\n",
          position: (379, 8),
         },
         Expression {
          expression: Variable {
           identifier: "refind",
           position: (392, 7),
          },
         },
         Raw {
          content: "\n",
          position: (392, 14),
         },
        ],
        position: (235, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "efiImg",
        position: (395, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (395, 12),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "runCommand",
          position: (395, 17),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "efi-image_eltorito",
          position: (395, 29),
         },
        ],
        position: (395, 28),
       },
       Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "nativeBuildInputs",
             position: (396, 5),
            },
           ],
          },
          to: List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (396, 27),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "buildPackages",
                position: (396, 32),
               },
               Raw {
                content: "mtools",
                position: (396, 46),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (396, 53),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "buildPackages",
                position: (396, 58),
               },
               Raw {
                content: "libfaketime",
                position: (396, 72),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (396, 84),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "buildPackages",
                position: (396, 89),
               },
               Raw {
                content: "dosfstools",
                position: (396, 103),
               },
              ],
             },
             default: None,
            },
           ],
           position: (396, 25),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "strictDeps",
             position: (397, 5),
            },
           ],
          },
          to: Variable {
           identifier: "true",
           position: (397, 18),
          },
         },
        ],
        recursive: false,
        position: (395, 49),
       },
       String {
        parts: [
         Raw {
          content: "mkdir ./contents && cd ./contents\ncp -rp \"",
          position: (402, 1),
         },
         Expression {
          expression: Variable {
           identifier: "efiDir",
           position: (403, 17),
          },
         },
         Raw {
          content: "\"/EFI .\nmkdir ./boot\ncp -p \"",
          position: (403, 24),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (405, 16),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "boot",
              position: (405, 23),
             },
             Raw {
              content: "kernelPackages",
              position: (405, 28),
             },
             Raw {
              content: "kernel",
              position: (405, 43),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/",
          position: (405, 50),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (405, 53),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "system",
              position: (405, 60),
             },
             Raw {
              content: "boot",
              position: (405, 67),
             },
             Raw {
              content: "loader",
              position: (405, 72),
             },
             Raw {
              content: "kernelFile",
              position: (405, 79),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\" \\\n  \"",
          position: (405, 90),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (406, 12),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "system",
              position: (406, 19),
             },
             Raw {
              content: "build",
              position: (406, 26),
             },
             Raw {
              content: "initialRamdisk",
              position: (406, 32),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/",
          position: (406, 47),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (406, 50),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "system",
              position: (406, 57),
             },
             Raw {
              content: "boot",
              position: (406, 64),
             },
             Raw {
              content: "loader",
              position: (406, 69),
             },
             Raw {
              content: "initrdFile",
              position: (406, 76),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\" ./boot/\n\n# Rewrite dates for everything in the FS\nfind . -exec touch --date=2000-01-01 {} +\n\n# Round up to the nearest multiple of 1MB, for more deterministic du output\nusage_size=$(( $(du -s --block-size=1M --apparent-size . | tr -cd '[:digit:]') * 1024 * 1024 ))\n# Make the image 110% as big as the files need to make up for FAT overhead\nimage_size=$(( ($usage_size * 110) / 100 ))\n# Make the image fit blocks of 1M\nblock_size=$((1024*1024))\nimage_size=$(( ($image_size / $block_size + 1) * $block_size ))\necho \"Usage size: $usage_size\"\necho \"Image size: $image_size\"\ntruncate --size=$image_size \"$out\"\nfaketime \"2000-01-01 00:00:00\" mkfs.vfat -i 12345678 -n EFIBOOT \"$out\"\n\n# Force a fixed order in mcopy for better determinism, and avoid file globbing\nfor d in $(find EFI boot -type d | sort); do\n  faketime \"2000-01-01 00:00:00\" mmd -i \"$out\" \"::/$d\"\ndone\n\nfor f in $(find EFI boot -type f | sort); do\n  mcopy -pvm -i \"$out\" \"$f\" \"::/$f\"\ndone\n\n# Verify the FAT partition.\nfsck.vfat -vn \"$out\"\n",
          position: (406, 87),
         },
        ],
        position: (401, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "targetArch",
        position: (437, 3),
       },
      ],
     },
     to: IfThenElse {
      predicate: BinaryOperation {
       operator: LogicalOr,
       operands: [
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (438, 8),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "stdenv",
            position: (438, 13),
           },
           Raw {
            content: "isi686",
            position: (438, 20),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (438, 30),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (438, 37),
           },
           Raw {
            content: "loader",
            position: (438, 42),
           },
           Raw {
            content: "grub",
            position: (438, 49),
           },
           Raw {
            content: "forcei686",
            position: (438, 54),
           },
          ],
         },
         default: None,
        },
       ],
       position: (438, 27),
      },
      then: String {
       parts: [
        Raw {
         content: "ia32",
         position: (439, 8),
        },
       ],
       position: (439, 7),
      },
      else_: IfThenElse {
       predicate: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (440, 13),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "stdenv",
           position: (440, 18),
          },
          Raw {
           content: "isx86_64",
           position: (440, 25),
          },
         ],
        },
        default: None,
       },
       then: String {
        parts: [
         Raw {
          content: "x64",
          position: (441, 8),
         },
        ],
        position: (441, 7),
       },
       else_: IfThenElse {
        predicate: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (442, 13),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "stdenv",
            position: (442, 18),
           },
           Raw {
            content: "isAarch32",
            position: (442, 25),
           },
          ],
         },
         default: None,
        },
        then: String {
         parts: [
          Raw {
           content: "arm",
           position: (443, 8),
          },
         ],
         position: (443, 7),
        },
        else_: IfThenElse {
         predicate: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (444, 13),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "stdenv",
             position: (444, 18),
            },
            Raw {
             content: "isAarch64",
             position: (444, 25),
            },
           ],
          },
          default: None,
         },
         then: String {
          parts: [
           Raw {
            content: "aa64",
            position: (445, 8),
           },
          ],
          position: (445, 7),
         },
         else_: FunctionApplication {
          function: Variable {
           identifier: "throw",
           position: (447, 7),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "Unsupported architecture",
              position: (447, 14),
             },
            ],
            position: (447, 13),
           },
          ],
         },
         position: (444, 10),
        },
        position: (442, 10),
       },
       position: (440, 10),
      },
      position: (438, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "canx86BiosBoot",
        position: (450, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (450, 20),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "stdenv",
         position: (450, 25),
        },
        Raw {
         content: "hostPlatform",
         position: (450, 32),
        },
        Raw {
         content: "isx86",
         position: (450, 45),
        },
       ],
      },
      default: None,
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (455, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (457, 5),
           },
           Raw {
            content: "isoName",
            position: (457, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (457, 24),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (458, 7),
                },
               ],
              },
              to: String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (458, 20),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "isoImage",
                     position: (458, 27),
                    },
                    Raw {
                     content: "isoBaseName",
                     position: (458, 36),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: ".iso",
                 position: (458, 48),
                },
               ],
               position: (458, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (459, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Name of the generated ISO image file.\n",
                 position: (460, 1),
                },
               ],
               position: (459, 21),
              },
             },
            ],
            recursive: false,
            position: (457, 33),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (464, 5),
           },
           Raw {
            content: "isoBaseName",
            position: (464, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (464, 28),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (465, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "nixos",
                 position: (465, 18),
                },
               ],
               position: (465, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (466, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Prefix of the name of the generated ISO image file.\n",
                 position: (467, 1),
                },
               ],
               position: (466, 21),
              },
             },
            ],
            recursive: false,
            position: (464, 37),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (471, 5),
           },
           Raw {
            content: "compressImage",
            position: (471, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (471, 30),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (472, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (472, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (473, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be compressed using\n<command>zstd</command>.\n",
                 position: (474, 1),
                },
               ],
               position: (473, 21),
              },
             },
            ],
            recursive: false,
            position: (471, 39),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (479, 5),
           },
           Raw {
            content: "squashfsCompression",
            position: (479, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (479, 36),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (480, 7),
                },
               ],
              },
              to: With {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (480, 22),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "stdenv",
                   position: (480, 27),
                  },
                  Raw {
                   content: "targetPlatform",
                   position: (480, 34),
                  },
                 ],
                },
                default: None,
               },
               target: BinaryOperation {
                operator: Addition,
                operands: [
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     BinaryOperation {
                      operator: Addition,
                      operands: [
                       String {
                        parts: [
                         Raw {
                          content: "xz -Xdict-size 100% ",
                          position: (480, 51),
                         },
                        ],
                        position: (480, 50),
                       },
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "lib",
                          position: (481, 19),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "optionalString",
                            position: (481, 23),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Parentheses {
                          expression: BinaryOperation {
                           operator: LogicalOr,
                           operands: [
                            Variable {
                             identifier: "isx86_32",
                             position: (481, 39),
                            },
                            Variable {
                             identifier: "isx86_64",
                             position: (481, 51),
                            },
                           ],
                           position: (481, 48),
                          },
                          position: (481, 38),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "-Xbcj x86",
                            position: (481, 62),
                           },
                          ],
                          position: (481, 61),
                         },
                        ],
                       },
                      ],
                      position: (481, 17),
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (483, 19),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "optionalString",
                          position: (483, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Parentheses {
                        expression: BinaryOperation {
                         operator: LogicalOr,
                         operands: [
                          Variable {
                           identifier: "isAarch32",
                           position: (483, 39),
                          },
                          Variable {
                           identifier: "isAarch64",
                           position: (483, 52),
                          },
                         ],
                         position: (483, 49),
                        },
                        position: (483, 38),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "-Xbcj arm",
                          position: (483, 64),
                         },
                        ],
                        position: (483, 63),
                       },
                      ],
                     },
                    ],
                    position: (483, 17),
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (484, 19),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "optionalString",
                        position: (484, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Parentheses {
                      expression: Variable {
                       identifier: "isPowerPC",
                       position: (484, 39),
                      },
                      position: (484, 38),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-Xbcj powerpc",
                        position: (484, 51),
                       },
                      ],
                      position: (484, 50),
                     },
                    ],
                   },
                  ],
                  position: (484, 17),
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (485, 19),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "optionalString",
                      position: (485, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: Variable {
                     identifier: "isSparc",
                     position: (485, 39),
                    },
                    position: (485, 38),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-Xbcj sparc",
                      position: (485, 49),
                     },
                    ],
                    position: (485, 48),
                   },
                  ],
                 },
                ],
                position: (485, 17),
               },
               position: (480, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (486, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Compression settings to use for the squashfs nix store.\n",
                 position: (487, 1),
                },
               ],
               position: (486, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (489, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "zstd -Xcompression-level 6",
                 position: (489, 18),
                },
               ],
               position: (489, 17),
              },
             },
            ],
            recursive: false,
            position: (479, 45),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (492, 5),
           },
           Raw {
            content: "edition",
            position: (492, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (492, 24),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (493, 7),
                },
               ],
              },
              to: String {
               parts: [],
               position: (493, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (494, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Specifies which edition string to use in the volume ID of the generated\nISO image.\n",
                 position: (495, 1),
                },
               ],
               position: (494, 21),
              },
             },
            ],
            recursive: false,
            position: (492, 33),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (500, 5),
           },
           Raw {
            content: "volumeID",
            position: (500, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (500, 25),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (502, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "nixos",
                 position: (502, 18),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (502, 25),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (502, 41),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "isoImage",
                          position: (502, 48),
                         },
                         Raw {
                          content: "edition",
                          position: (502, 57),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [],
                       position: (502, 68),
                      },
                     ],
                     position: (502, 65),
                    },
                    position: (502, 40),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-",
                      position: (502, 73),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (502, 76),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "isoImage",
                          position: (502, 83),
                         },
                         Raw {
                          content: "edition",
                          position: (502, 92),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                    position: (502, 72),
                   },
                  ],
                 },
                },
                Raw {
                 content: "-",
                 position: (502, 102),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (502, 105),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "system",
                     position: (502, 112),
                    },
                    Raw {
                     content: "nixos",
                     position: (502, 119),
                    },
                    Raw {
                     content: "release",
                     position: (502, 125),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "-",
                 position: (502, 133),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (502, 136),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "stdenv",
                     position: (502, 141),
                    },
                    Raw {
                     content: "hostPlatform",
                     position: (502, 148),
                    },
                    Raw {
                     content: "uname",
                     position: (502, 161),
                    },
                    Raw {
                     content: "processor",
                     position: (502, 167),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
               position: (502, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (503, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Specifies the label or volume ID of the generated ISO image.\nNote that the label is used by stage 1 of the boot process to\nmount the CD, so it should be reasonably distinctive.\n",
                 position: (504, 1),
                },
               ],
               position: (503, 21),
              },
             },
            ],
            recursive: false,
            position: (500, 34),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (510, 5),
           },
           Raw {
            content: "contents",
            position: (510, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (510, 25),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (511, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (511, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ { source = pkgs.memtest86 + \"/memtest.bin\";\n    target = \"boot/memtest.bin\";\n  }\n]\n",
                   position: (512, 1),
                  },
                 ],
                 position: (511, 35),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (517, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "This option lists files to be copied to fixed locations in the\ngenerated ISO image.\n",
                 position: (518, 1),
                },
               ],
               position: (517, 21),
              },
             },
            ],
            recursive: false,
            position: (510, 34),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (523, 5),
           },
           Raw {
            content: "storeContents",
            position: (523, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (523, 30),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (524, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (524, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ pkgs.stdenv ]",
                   position: (524, 36),
                  },
                 ],
                 position: (524, 35),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (525, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "This option lists additional derivations to be included in the\nNix store in the generated ISO image.\n",
                 position: (526, 1),
                },
               ],
               position: (525, 21),
              },
             },
            ],
            recursive: false,
            position: (523, 39),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (531, 5),
           },
           Raw {
            content: "includeSystemBuildDependencies",
            position: (531, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (531, 47),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (532, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (532, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (533, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Set this option to include all the needed sources etc in the\nimage. It significantly increases image size. Use that when\nyou want to be able to keep all the sources needed to build your\nsystem or when you are going to install the system on a computer\nwith slow or non-existent network connection.\n",
                 position: (534, 1),
                },
               ],
               position: (533, 21),
              },
             },
            ],
            recursive: false,
            position: (531, 56),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (542, 5),
           },
           Raw {
            content: "makeEfiBootable",
            position: (542, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (542, 32),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (543, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (543, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (544, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be an efi-bootable volume.\n",
                 position: (545, 1),
                },
               ],
               position: (544, 21),
              },
             },
            ],
            recursive: false,
            position: (542, 41),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (549, 5),
           },
           Raw {
            content: "makeUsbBootable",
            position: (549, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (549, 32),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (550, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (550, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (551, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be bootable from CD as well as USB.\n",
                 position: (552, 1),
                },
               ],
               position: (551, 21),
              },
             },
            ],
            recursive: false,
            position: (549, 41),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (556, 5),
           },
           Raw {
            content: "efiSplashImage",
            position: (556, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (556, 31),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (557, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (557, 17),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "fetchurl",
                   position: (557, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "url",
                      position: (558, 11),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "https://raw.githubusercontent.com/NixOS/nixos-artwork/a9e05d7deb38a8e005a2b52575a3f59a63a4dba0/bootloader/efi-background.png",
                      position: (558, 18),
                     },
                    ],
                    position: (558, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "sha256",
                      position: (559, 11),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "18lfwmp8yq923322nlb9gxrh5qikj1wsk6g5qvdh31c4h5b1538x",
                      position: (559, 21),
                     },
                    ],
                    position: (559, 20),
                   },
                  },
                 ],
                 recursive: false,
                 position: (557, 31),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (561, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "The splash image to use in the EFI bootloader.\n",
                 position: (562, 1),
                },
               ],
               position: (561, 21),
              },
             },
            ],
            recursive: false,
            position: (556, 40),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (566, 5),
           },
           Raw {
            content: "splashImage",
            position: (566, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (566, 28),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (567, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (567, 17),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "fetchurl",
                   position: (567, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "url",
                      position: (568, 11),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "https://raw.githubusercontent.com/NixOS/nixos-artwork/a9e05d7deb38a8e005a2b52575a3f59a63a4dba0/bootloader/isolinux/bios-boot.png",
                      position: (568, 18),
                     },
                    ],
                    position: (568, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "sha256",
                      position: (569, 11),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "1wp822zrhbg4fgfbwkr7cbkr4labx477209agzc0hr6k62fr6rxd",
                      position: (569, 21),
                     },
                    ],
                    position: (569, 20),
                   },
                  },
                 ],
                 recursive: false,
                 position: (567, 31),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (571, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "The splash image to use in the legacy-boot bootloader.\n",
                 position: (572, 1),
                },
               ],
               position: (571, 21),
              },
             },
            ],
            recursive: false,
            position: (566, 37),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (576, 5),
           },
           Raw {
            content: "grubTheme",
            position: (576, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (576, 26),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (577, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (577, 17),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "nixos-grub2-theme",
                  position: (577, 22),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (578, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (578, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "nullOr",
                   position: (578, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (578, 28),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "either",
                      position: (578, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (578, 41),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "path",
                       position: (578, 47),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (578, 52),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "package",
                       position: (578, 58),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 position: (578, 27),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (579, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "The grub2 theme used for UEFI boot.\n",
                 position: (580, 1),
                },
               ],
               position: (579, 21),
              },
             },
            ],
            recursive: false,
            position: (576, 35),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (584, 5),
           },
           Raw {
            content: "syslinuxTheme",
            position: (584, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (584, 30),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (585, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "MENU TITLE NixOS\nMENU RESOLUTION 800 600\nMENU CLEAR\nMENU ROWS 6\nMENU CMDLINEROW -4\nMENU TIMEOUTROW -3\nMENU TABMSGROW  -2\nMENU HELPMSGROW -1\nMENU HELPMSGENDROW -1\nMENU MARGIN 0\n\n#                                FG:AARRGGBB  BG:AARRGGBB   shadow\nMENU COLOR BORDER       30;44      #00000000    #00000000   none\nMENU COLOR SCREEN       37;40      #FF000000    #00E2E8FF   none\nMENU COLOR TABMSG       31;40      #80000000    #00000000   none\nMENU COLOR TIMEOUT      1;37;40    #FF000000    #00000000   none\nMENU COLOR TIMEOUT_MSG  37;40      #FF000000    #00000000   none\nMENU COLOR CMDMARK      1;36;40    #FF000000    #00000000   none\nMENU COLOR CMDLINE      37;40      #FF000000    #00000000   none\nMENU COLOR TITLE        1;36;44    #00000000    #00000000   none\nMENU COLOR UNSEL        37;44      #FF000000    #00000000   none\nMENU COLOR SEL          7;37;40    #FFFFFFFF    #FF5277C3   std\n",
                 position: (586, 1),
                },
               ],
               position: (585, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (609, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (609, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "str",
                  position: (609, 20),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (610, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "The syslinux theme used for BIOS boot.\n",
                 position: (611, 1),
                },
               ],
               position: (610, 21),
              },
             },
            ],
            recursive: false,
            position: (584, 39),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (615, 5),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (615, 14),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (615, 34),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (616, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: " Installer",
                 position: (616, 18),
                },
               ],
               position: (616, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (617, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: " Live System",
                 position: (617, 18),
                },
               ],
               position: (617, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (618, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "The string to append after the menu label for the NixOS system.\nThis will be directly appended (without whitespace) to the NixOS version\nstring, like for example if it is set to <literal>XXX</literal>:\n\n<para><literal>NixOS 99.99-pre666XXX</literal></para>\n",
                 position: (619, 1),
                },
               ],
               position: (618, 21),
              },
             },
            ],
            recursive: false,
            position: (615, 43),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (455, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (631, 3),
        },
        Raw {
         content: "lib",
         position: (631, 10),
        },
        Raw {
         content: "isoFileSystems",
         position: (631, 14),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/",
               position: (632, 6),
              },
             ],
             position: (632, 5),
            },
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (632, 11),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "fsType",
                 position: (634, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "tmpfs",
                 position: (634, 19),
                },
               ],
               position: (634, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (635, 9),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "mode=0755",
                   position: (635, 22),
                  },
                 ],
                 position: (635, 21),
                },
               ],
               position: (635, 19),
              },
             },
            ],
            recursive: false,
            position: (633, 7),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/iso",
               position: (641, 6),
              },
             ],
             position: (641, 5),
            },
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (641, 14),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "device",
                 position: (642, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "/dev/root",
                 position: (642, 19),
                },
               ],
               position: (642, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "neededForBoot",
                 position: (643, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (643, 25),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "noCheck",
                 position: (644, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (644, 19),
              },
             },
            ],
            recursive: false,
            position: (642, 7),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/.ro-store",
               position: (649, 6),
              },
             ],
             position: (649, 5),
            },
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (649, 24),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "fsType",
                 position: (650, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "squashfs",
                 position: (650, 19),
                },
               ],
               position: (650, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "device",
                 position: (651, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "/iso/nix-store.squashfs",
                 position: (651, 19),
                },
               ],
               position: (651, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (652, 9),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "loop",
                   position: (652, 22),
                  },
                 ],
                 position: (652, 21),
                },
               ],
               position: (652, 19),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "neededForBoot",
                 position: (653, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (653, 25),
              },
             },
            ],
            recursive: false,
            position: (650, 7),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/.rw-store",
               position: (656, 6),
              },
             ],
             position: (656, 5),
            },
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (656, 24),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "fsType",
                 position: (657, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "tmpfs",
                 position: (657, 19),
                },
               ],
               position: (657, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (658, 9),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "mode=0755",
                   position: (658, 22),
                  },
                 ],
                 position: (658, 21),
                },
               ],
               position: (658, 19),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "neededForBoot",
                 position: (659, 9),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (659, 25),
              },
             },
            ],
            recursive: false,
            position: (657, 7),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/store",
               position: (662, 6),
              },
             ],
             position: (662, 5),
            },
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (662, 20),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "fsType",
                 position: (663, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "overlay",
                 position: (663, 19),
                },
               ],
               position: (663, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "device",
                 position: (664, 9),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "overlay",
                 position: (664, 19),
                },
               ],
               position: (664, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (665, 9),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "lowerdir=/nix/.ro-store",
                   position: (666, 12),
                  },
                 ],
                 position: (666, 11),
                },
                String {
                 parts: [
                  Raw {
                   content: "upperdir=/nix/.rw-store/store",
                   position: (667, 12),
                  },
                 ],
                 position: (667, 11),
                },
                String {
                 parts: [
                  Raw {
                   content: "workdir=/nix/.rw-store/work",
                   position: (668, 12),
                  },
                 ],
                 position: (668, 11),
                },
               ],
               position: (665, 19),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "depends",
                 position: (670, 9),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "/nix/.ro-store",
                   position: (671, 12),
                  },
                 ],
                 position: (671, 11),
                },
                String {
                 parts: [
                  Raw {
                   content: "/nix/.rw-store/store",
                   position: (672, 12),
                  },
                 ],
                 position: (672, 11),
                },
                String {
                 parts: [
                  Raw {
                   content: "/nix/.rw-store/work",
                   position: (673, 12),
                  },
                 ],
                 position: (673, 11),
                },
               ],
               position: (670, 19),
              },
             },
            ],
            recursive: false,
            position: (663, 7),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (631, 31),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (678, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "assertions",
            position: (679, 5),
           },
          ],
         },
         to: List {
          elements: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "assertion",
                 position: (681, 9),
                },
               ],
              },
              to: UnaryOperation {
               operator: Not,
               operand: Parentheses {
                expression: BinaryOperation {
                 operator: GreaterThan,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "stringLength",
                    position: (681, 23),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (681, 36),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "isoImage",
                        position: (681, 43),
                       },
                       Raw {
                        content: "volumeID",
                        position: (681, 52),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  Int {
                   value: 32,
                   position: (681, 63),
                  },
                 ],
                 position: (681, 61),
                },
                position: (681, 22),
               },
               position: (681, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "message",
                 position: (684, 9),
                },
               ],
              },
              to: LetIn {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "length",
                    position: (685, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "stringLength",
                   position: (685, 20),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (685, 33),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "isoImage",
                       position: (685, 40),
                      },
                      Raw {
                       content: "volumeID",
                       position: (685, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "howmany",
                    position: (686, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (686, 21),
                  },
                  arguments: [
                   Variable {
                    identifier: "length",
                    position: (686, 30),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "toomany",
                    position: (687, 11),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (687, 21),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: Subtraction,
                     operands: [
                      Variable {
                       identifier: "length",
                       position: (687, 31),
                      },
                      Int {
                       value: 32,
                       position: (687, 40),
                      },
                     ],
                     position: (687, 38),
                    },
                    position: (687, 30),
                   },
                  ],
                 },
                },
               ],
               target: String {
                parts: [
                 Raw {
                  content: "isoImage.volumeID ",
                  position: (689, 10),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (689, 30),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "isoImage",
                      position: (689, 37),
                     },
                     Raw {
                      content: "volumeID",
                      position: (689, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: " is ",
                  position: (689, 55),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "howmany",
                   position: (689, 61),
                  },
                 },
                 Raw {
                  content: " characters. That is ",
                  position: (689, 69),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "toomany",
                   position: (689, 92),
                  },
                 },
                 Raw {
                  content: " characters longer than the limit of 32.",
                  position: (689, 100),
                 },
                ],
                position: (689, 9),
               },
               position: (684, 19),
              },
             },
            ],
            recursive: false,
            position: (680, 7),
           },
          ],
          position: (679, 18),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (693, 5),
           },
           Raw {
            content: "loader",
            position: (693, 10),
           },
           Raw {
            content: "grub",
            position: (693, 17),
           },
           Raw {
            content: "version",
            position: (693, 22),
           },
          ],
         },
         to: Int {
          value: 2,
          position: (693, 32),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (697, 5),
           },
           Raw {
            content: "loader",
            position: (697, 10),
           },
           Raw {
            content: "grub",
            position: (697, 17),
           },
           Raw {
            content: "enable",
            position: (697, 22),
           },
          ],
         },
         to: Variable {
          identifier: "false",
          position: (697, 31),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "environment",
            position: (699, 5),
           },
           Raw {
            content: "systemPackages",
            position: (699, 17),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "grubPkgs",
               position: (699, 37),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "grub2",
                 position: (699, 46),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "grubPkgs",
               position: (699, 52),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "grub2_efi",
                 position: (699, 61),
                },
               ],
              },
              default: None,
             },
            ],
            position: (699, 35),
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (700, 10),
            },
            arguments: [
             Variable {
              identifier: "canx86BiosBoot",
              position: (700, 19),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (700, 34),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "syslinux",
                 position: (700, 39),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
          position: (700, 7),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (711, 5),
           },
           Raw {
            content: "kernelParams",
            position: (711, 10),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "root=LABEL=",
              position: (712, 10),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (712, 23),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "isoImage",
                  position: (712, 30),
                 },
                 Raw {
                  content: "volumeID",
                  position: (712, 39),
                 },
                ],
               },
               default: None,
              },
             },
            ],
            position: (712, 9),
           },
           String {
            parts: [
             Raw {
              content: "boot.shell_on_fail",
              position: (713, 10),
             },
            ],
            position: (713, 9),
           },
          ],
          position: (712, 7),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "fileSystems",
            position: (716, 5),
           },
          ],
         },
         to: PropertyAccess {
          expression: Variable {
           identifier: "config",
           position: (716, 19),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "lib",
             position: (716, 26),
            },
            Raw {
             content: "isoFileSystems",
             position: (716, 30),
            },
           ],
          },
          default: None,
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (718, 5),
           },
           Raw {
            content: "initrd",
            position: (718, 10),
           },
           Raw {
            content: "availableKernelModules",
            position: (718, 17),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "squashfs",
              position: (718, 45),
             },
            ],
            position: (718, 44),
           },
           String {
            parts: [
             Raw {
              content: "iso9660",
              position: (718, 56),
             },
            ],
            position: (718, 55),
           },
           String {
            parts: [
             Raw {
              content: "uas",
              position: (718, 66),
             },
            ],
            position: (718, 65),
           },
           String {
            parts: [
             Raw {
              content: "overlay",
              position: (718, 72),
             },
            ],
            position: (718, 71),
           },
          ],
          position: (718, 42),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (720, 5),
           },
           Raw {
            content: "initrd",
            position: (720, 10),
           },
           Raw {
            content: "kernelModules",
            position: (720, 17),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "loop",
              position: (720, 36),
             },
            ],
            position: (720, 35),
           },
           String {
            parts: [
             Raw {
              content: "overlay",
              position: (720, 43),
             },
            ],
            position: (720, 42),
           },
          ],
          position: (720, 33),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (724, 5),
           },
           Raw {
            content: "storeContents",
            position: (724, 14),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (725, 9),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (725, 16),
                },
                Raw {
                 content: "build",
                 position: (725, 23),
                },
                Raw {
                 content: "toplevel",
                 position: (725, 29),
                },
               ],
              },
              default: None,
             },
            ],
            position: (725, 7),
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (726, 7),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (726, 16),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "isoImage",
                 position: (726, 23),
                },
                Raw {
                 content: "includeSystemBuildDependencies",
                 position: (726, 32),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (727, 9),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (727, 16),
                },
                Raw {
                 content: "build",
                 position: (727, 23),
                },
                Raw {
                 content: "toplevel",
                 position: (727, 29),
                },
                Raw {
                 content: "drvPath",
                 position: (727, 38),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
          position: (725, 40),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (730, 5),
           },
           Raw {
            content: "build",
            position: (730, 12),
           },
           Raw {
            content: "squashfsStore",
            position: (730, 18),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (730, 34),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "callPackage",
              position: (730, 39),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "../../../lib/make-squashfs.nix",
              position: (730, 51),
             },
            ],
            position: (730, 51),
           },
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "storeContents",
                 position: (731, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (731, 23),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "isoImage",
                  position: (731, 30),
                 },
                 Raw {
                  content: "storeContents",
                  position: (731, 39),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "comp",
                 position: (732, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (732, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "isoImage",
                  position: (732, 21),
                 },
                 Raw {
                  content: "squashfsCompression",
                  position: (732, 30),
                 },
                ],
               },
               default: None,
              },
             },
            ],
            recursive: false,
            position: (730, 82),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "isoImage",
            position: (737, 5),
           },
           Raw {
            content: "contents",
            position: (737, 14),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "source",
                   position: (739, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (739, 20),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "boot",
                        position: (739, 27),
                       },
                       Raw {
                        content: "kernelPackages",
                        position: (739, 32),
                       },
                       Raw {
                        content: "kernel",
                        position: (739, 47),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/",
                       position: (739, 57),
                      },
                     ],
                     position: (739, 56),
                    },
                   ],
                   position: (739, 54),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (739, 62),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "system",
                      position: (739, 69),
                     },
                     Raw {
                      content: "boot",
                      position: (739, 76),
                     },
                     Raw {
                      content: "loader",
                      position: (739, 81),
                     },
                     Raw {
                      content: "kernelFile",
                      position: (739, 88),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (739, 60),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "target",
                   position: (740, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "/boot/",
                     position: (740, 21),
                    },
                   ],
                   position: (740, 20),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (740, 31),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "system",
                      position: (740, 38),
                     },
                     Raw {
                      content: "boot",
                      position: (740, 45),
                     },
                     Raw {
                      content: "loader",
                      position: (740, 50),
                     },
                     Raw {
                      content: "kernelFile",
                      position: (740, 57),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (740, 29),
                },
               },
              ],
              recursive: false,
              position: (739, 9),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "source",
                   position: (742, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (742, 20),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "system",
                        position: (742, 27),
                       },
                       Raw {
                        content: "build",
                        position: (742, 34),
                       },
                       Raw {
                        content: "initialRamdisk",
                        position: (742, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/",
                       position: (742, 58),
                      },
                     ],
                     position: (742, 57),
                    },
                   ],
                   position: (742, 55),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (742, 63),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "system",
                      position: (742, 70),
                     },
                     Raw {
                      content: "boot",
                      position: (742, 77),
                     },
                     Raw {
                      content: "loader",
                      position: (742, 82),
                     },
                     Raw {
                      content: "initrdFile",
                      position: (742, 89),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (742, 61),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "target",
                   position: (743, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "/boot/",
                     position: (743, 21),
                    },
                   ],
                   position: (743, 20),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (743, 31),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "system",
                      position: (743, 38),
                     },
                     Raw {
                      content: "boot",
                      position: (743, 45),
                     },
                     Raw {
                      content: "loader",
                      position: (743, 50),
                     },
                     Raw {
                      content: "initrdFile",
                      position: (743, 57),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (743, 29),
                },
               },
              ],
              recursive: false,
              position: (742, 9),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "source",
                   position: (745, 11),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (745, 20),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "system",
                    position: (745, 27),
                   },
                   Raw {
                    content: "build",
                    position: (745, 34),
                   },
                   Raw {
                    content: "squashfsStore",
                    position: (745, 40),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "target",
                   position: (746, 11),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "/nix-store.squashfs",
                   position: (746, 21),
                  },
                 ],
                 position: (746, 20),
                },
               },
              ],
              recursive: false,
              position: (745, 9),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "source",
                   position: (748, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (748, 20),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "writeText",
                     position: (748, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "version",
                     position: (748, 36),
                    },
                   ],
                   position: (748, 35),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (748, 45),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "system",
                      position: (748, 52),
                     },
                     Raw {
                      content: "nixos",
                      position: (748, 59),
                     },
                     Raw {
                      content: "label",
                      position: (748, 65),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "target",
                   position: (749, 11),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "/version.txt",
                   position: (749, 21),
                  },
                 ],
                 position: (749, 20),
                },
               },
              ],
              recursive: false,
              position: (748, 9),
             },
            ],
            position: (738, 7),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optionals",
               position: (751, 12),
              },
              arguments: [
               Variable {
                identifier: "canx86BiosBoot",
                position: (751, 22),
               },
               List {
                elements: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "source",
                       position: (752, 11),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (752, 20),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "isoImage",
                        position: (752, 27),
                       },
                       Raw {
                        content: "splashImage",
                        position: (752, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "target",
                       position: (753, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/isolinux/background.png",
                       position: (753, 21),
                      },
                     ],
                     position: (753, 20),
                    },
                   },
                  ],
                  recursive: false,
                  position: (752, 9),
                 },
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "source",
                       position: (755, 11),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (755, 20),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "substituteAll",
                         position: (755, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "name",
                            position: (756, 13),
                           },
                          ],
                         },
                         to: String {
                          parts: [
                           Raw {
                            content: "isolinux.cfg",
                            position: (756, 21),
                           },
                          ],
                          position: (756, 20),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "src",
                            position: (757, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (757, 19),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "writeText",
                              position: (757, 24),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "isolinux.cfg-in",
                              position: (757, 35),
                             },
                            ],
                            position: (757, 34),
                           },
                           Variable {
                            identifier: "isolinuxCfg",
                            position: (757, 52),
                           },
                          ],
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "bootRoot",
                            position: (758, 13),
                           },
                          ],
                         },
                         to: String {
                          parts: [
                           Raw {
                            content: "/boot",
                            position: (758, 25),
                           },
                          ],
                          position: (758, 24),
                         },
                        },
                       ],
                       recursive: false,
                       position: (755, 40),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "target",
                       position: (760, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/isolinux/isolinux.cfg",
                       position: (760, 21),
                      },
                     ],
                     position: (760, 20),
                    },
                   },
                  ],
                  recursive: false,
                  position: (755, 9),
                 },
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "source",
                       position: (762, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (762, 23),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "syslinux",
                           position: (762, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/share/syslinux",
                       position: (762, 37),
                      },
                     ],
                     position: (762, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "target",
                       position: (763, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/isolinux",
                       position: (763, 21),
                      },
                     ],
                     position: (763, 20),
                    },
                   },
                  ],
                  recursive: false,
                  position: (762, 9),
                 },
                ],
                position: (751, 37),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optionals",
                 position: (765, 12),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (765, 22),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "isoImage",
                     position: (765, 29),
                    },
                    Raw {
                     content: "makeEfiBootable",
                     position: (765, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "source",
                         position: (766, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "efiImg",
                       position: (766, 20),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "target",
                         position: (767, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "/boot/efi.img",
                         position: (767, 21),
                        },
                       ],
                       position: (767, 20),
                      },
                     },
                    ],
                    recursive: false,
                    position: (766, 9),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "source",
                         position: (769, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "efiDir",
                          position: (769, 23),
                         },
                        },
                        Raw {
                         content: "/EFI",
                         position: (769, 30),
                        },
                       ],
                       position: (769, 20),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "target",
                         position: (770, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "/EFI",
                         position: (770, 21),
                        },
                       ],
                       position: (770, 20),
                      },
                     },
                    ],
                    recursive: false,
                    position: (769, 9),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "source",
                         position: (772, 11),
                        },
                       ],
                      },
                      to: BinaryOperation {
                       operator: Addition,
                       operands: [
                        Parentheses {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (772, 21),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "writeTextDir",
                              position: (772, 26),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "grub/loopback.cfg",
                              position: (772, 40),
                             },
                            ],
                            position: (772, 39),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "source /EFI/boot/grub.cfg",
                              position: (772, 60),
                             },
                            ],
                            position: (772, 59),
                           },
                          ],
                         },
                         position: (772, 20),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/grub",
                           position: (772, 91),
                          },
                         ],
                         position: (772, 90),
                        },
                       ],
                       position: (772, 88),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "target",
                         position: (773, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "/boot/grub",
                         position: (773, 21),
                        },
                       ],
                       position: (773, 20),
                      },
                     },
                    ],
                    recursive: false,
                    position: (772, 9),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "source",
                         position: (775, 11),
                        },
                       ],
                      },
                      to: PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (775, 20),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "isoImage",
                          position: (775, 27),
                         },
                         Raw {
                          content: "efiSplashImage",
                          position: (775, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "target",
                         position: (776, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "/EFI/boot/efi-background.png",
                         position: (776, 21),
                        },
                       ],
                       position: (776, 20),
                      },
                     },
                    ],
                    recursive: false,
                    position: (775, 9),
                   },
                  ],
                  position: (765, 54),
                 },
                ],
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (778, 12),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (778, 23),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "boot",
                          position: (778, 30),
                         },
                         Raw {
                          content: "loader",
                          position: (778, 35),
                         },
                         Raw {
                          content: "grub",
                          position: (778, 42),
                         },
                         Raw {
                          content: "memtest86",
                          position: (778, 47),
                         },
                         Raw {
                          content: "enable",
                          position: (778, 57),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "canx86BiosBoot",
                       position: (778, 67),
                      },
                     ],
                     position: (778, 64),
                    },
                    position: (778, 22),
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "source",
                           position: (779, 11),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (779, 23),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "memtest86plus",
                               position: (779, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/memtest.bin",
                           position: (779, 42),
                          },
                         ],
                         position: (779, 20),
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "target",
                           position: (780, 11),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "/boot/memtest.bin",
                           position: (780, 21),
                          },
                         ],
                         position: (780, 20),
                        },
                       },
                      ],
                      recursive: false,
                      position: (779, 9),
                     },
                    ],
                    position: (778, 83),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (782, 12),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (782, 23),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "isoImage",
                          position: (782, 30),
                         },
                         Raw {
                          content: "grubTheme",
                          position: (782, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "null",
                       position: (782, 52),
                      },
                     ],
                     position: (782, 49),
                    },
                    position: (782, 22),
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "source",
                           position: (783, 11),
                          },
                         ],
                        },
                        to: PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (783, 20),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "isoImage",
                            position: (783, 27),
                           },
                           Raw {
                            content: "grubTheme",
                            position: (783, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "target",
                           position: (784, 11),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "/EFI/boot/grub-theme",
                           position: (784, 21),
                          },
                         ],
                         position: (784, 20),
                        },
                       },
                      ],
                      recursive: false,
                      position: (783, 9),
                     },
                    ],
                    position: (782, 58),
                   },
                  ],
                 },
                ],
                position: (782, 9),
               },
              ],
              position: (778, 9),
             },
            ],
            position: (765, 9),
           },
          ],
          position: (751, 9),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (788, 5),
           },
           Raw {
            content: "loader",
            position: (788, 10),
           },
           Raw {
            content: "timeout",
            position: (788, 17),
           },
          ],
         },
         to: Int {
          value: 10,
          position: (788, 27),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (791, 5),
           },
           Raw {
            content: "build",
            position: (791, 12),
           },
           Raw {
            content: "isoImage",
            position: (791, 18),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (791, 29),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "callPackage",
              position: (791, 34),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "../../../lib/make-iso9660-image.nix",
              position: (791, 46),
             },
            ],
            position: (791, 46),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: Update,
             operands: [
              Map {
               bindings: [
                Inherit {
                 from: Some(
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (792, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "isoImage",
                      position: (792, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 attributes: [
                  Raw {
                   content: "isoName",
                   position: (792, 33),
                  },
                  Raw {
                   content: "compressImage",
                   position: (792, 41),
                  },
                  Raw {
                   content: "volumeID",
                   position: (792, 55),
                  },
                  Raw {
                   content: "contents",
                   position: (792, 64),
                  },
                 ],
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "bootable",
                    position: (793, 7),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "canx86BiosBoot",
                  position: (793, 18),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "bootImage",
                    position: (794, 7),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "/isolinux/isolinux.bin",
                    position: (794, 20),
                   },
                  ],
                  position: (794, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "syslinux",
                    position: (795, 7),
                   },
                  ],
                 },
                 to: IfThenElse {
                  predicate: Variable {
                   identifier: "canx86BiosBoot",
                   position: (795, 21),
                  },
                  then: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (795, 41),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "syslinux",
                      position: (795, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                  else_: Variable {
                   identifier: "null",
                   position: (795, 60),
                  },
                  position: (795, 18),
                 },
                },
               ],
               recursive: false,
               position: (791, 83),
              },
              BinaryOperation {
               operator: Update,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (796, 10),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (796, 25),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "isoImage",
                         position: (796, 32),
                        },
                        Raw {
                         content: "makeUsbBootable",
                         position: (796, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "canx86BiosBoot",
                      position: (796, 60),
                     },
                    ],
                    position: (796, 57),
                   },
                   position: (796, 24),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "usbBootable",
                        position: (797, 7),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "true",
                      position: (797, 21),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "isohybridMbrImage",
                        position: (798, 7),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (798, 30),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "syslinux",
                            position: (798, 35),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/share/syslinux/isohdpfx.bin",
                        position: (798, 44),
                       },
                      ],
                      position: (798, 27),
                     },
                    },
                   ],
                   recursive: false,
                   position: (796, 76),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (799, 10),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (799, 24),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "isoImage",
                      position: (799, 31),
                     },
                     Raw {
                      content: "makeEfiBootable",
                      position: (799, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "efiBootable",
                        position: (800, 7),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "true",
                      position: (800, 21),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "efiBootImage",
                        position: (801, 7),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "boot/efi.img",
                        position: (801, 23),
                       },
                      ],
                      position: (801, 22),
                     },
                    },
                   ],
                   recursive: false,
                   position: (799, 56),
                  },
                 ],
                },
               ],
               position: (799, 7),
              },
             ],
             position: (796, 7),
            },
            position: (791, 82),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (804, 5),
           },
           Raw {
            content: "postBootCommands",
            position: (804, 10),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "# After booting, register the contents of the Nix store on the\n# CD in the Nix database in the tmpfs.\n",
            position: (806, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (808, 11),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "nix",
                position: (808, 18),
               },
               Raw {
                content: "package",
                position: (808, 22),
               },
               Raw {
                content: "out",
                position: (808, 30),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-store --load-db < /nix/store/nix-path-registration\n\n# nixos-rebuild also requires a \"system\" profile and an\n# /etc/NIXOS tag.\ntouch /etc/NIXOS\n",
            position: (808, 34),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (813, 11),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "nix",
                position: (813, 18),
               },
               Raw {
                content: "package",
                position: (813, 22),
               },
               Raw {
                content: "out",
                position: (813, 30),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-env -p /nix/var/nix/profiles/system --set /run/current-system\n",
            position: (813, 34),
           },
          ],
          position: (805, 7),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "boot",
            position: (818, 5),
           },
           Raw {
            content: "initrd",
            position: (818, 10),
           },
           Raw {
            content: "supportedFilesystems",
            position: (818, 17),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "vfat",
              position: (818, 43),
             },
            ],
            position: (818, 42),
           },
          ],
          position: (818, 40),
         },
        },
       ],
       recursive: false,
       position: (678, 12),
      },
     },
    ],
    recursive: false,
    position: (454, 1),
   },
   position: (9, 1),
  },
  position: (7, 1),
 },
 position: (5, 1),
}